java必学必会之线程(1)

一、线程的基本概念

  

线程理解:线程是一个程序里面不同的执行路径

  每一个分支都叫做一个线程,main()叫做主分支,也叫主线程。

  程只是一个静态的概念,机器上的一个.class文件,机器上的一个.exe文件,这个叫做一个进程。程序的执行过程都是这样的:首先把程序的代码放到内存的代码区里面,代码放到代码区后并没有马上开始执行,但这时候说明了一个进程准备开始,进程已经产生了,但还没有开始执行,这就是进程,所以进程其实是一个静态的概念,它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了,也就是main()方法开始执行了。进程是一个静态的概念,在我们机器里面实际上运行的都是线程。

  Windows操作系统是支持多线程的,它可以同时执行很多个线程,也支持多进程,因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了,它只支持单进程,在同一个时间点只能有一个进程在执行,这就叫单线程。

  CPU难道真的很神通广大,能够同时执行那么多程序吗?不是的,CPU的执行是这样的:CPU的速度很快,一秒钟可以算好几亿次,因此CPU把自己的时间分成一个个小时间片,我这个时间片执行你一会,下一个时间片执行他一会,再下一个时间片又执行其他人一会,虽然有几十个线程,但一样可以在很短的时间内把他们通通都执行一遍,但对我们人来说,CPU的执行速度太快了,因此看起来就像是在同时执行一样,但实际上在一个时间点上,CPU只有一个线程在运行。

学习线程首先要理清楚三个概念

1、进程:进程是一个静态的概念
2、线程:一个进程里面有一个主线程叫main()方法,是一个程序里面的,一个进程里面不同的执行路径。
3、在同一个时间点上,一个CPU只能支持一个线程在执行。因为CPU运行的速度很快,因此我们看起来的感觉就像是多线程一样。
  什么才是真正的多线程?如果你的机器是双CPU,或者是双核,这确确实实是多线程。

二、线程的创建和启动

  

  在JAVA里面,JAVA的线程是通过java.lang.Thread类来实现的,每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法:第一个是从Thread类继承,另一个是实现接口runnable。VM启动时会有一个由主方法(public static void main())所定义的线程,这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象,一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。

范例1:使用实现Runnable接口创建和启动新线程

开辟一个新的线程来调用run方法

package cn.galc.test;

public class TestThread1{
 public static void main(String args[]){
 Runner1 r1 = new Runner1();//这里new了一个线程类的对象出来
 //r1.run();//这个称为方法调用,方法调用的执行是等run()方法执行完之后才会继续执行main()方法
 Thread t = new Thread(r1);//要启动一个新的线程就必须new一个Thread对象出来
 //这里使用的是Thread(Runnable target) 这构造方法
 t.start();//启动新开辟的线程,新线程执行的是run()方法,新线程与主线程会一起并行执行
 for(int i=0;i<10;i++){
  System.out.println("maintheod:"+i);
 }
 }
}
/*定义一个类用来实现Runnable接口,实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
 public void run(){
 for(int i=0;i<10;i++){
  System.out.println("Runner1:"+i);
 }
 }
}

多线程程序执行的过程如下所示:

 

不开辟新线程直接调用run方法

 

运行结果如下:

范例2:继承Thread类,并重写其run()方法创建和启动新的线程

package cn.galc.test;

/*线程创建与启动的第二种方法:定义Thread的子类并实现run()方法*/
public class TestThread2{
 public static void main(String args[]){
 Runner2 r2 = new Runner2();
 r2.start();//调用start()方法启动新开辟的线程
 for(int i=0;i<=10;i++){
  System.out.println("mainMethod:"+i);
 }
 }
}
/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
 public void run(){//重写run()方法的实现
 for(int i=0;i<=10;i++){
  System.out.println("Runner2:"+i);
 }
 }
}

  使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个,而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。

三、线程状态转换

  

3.1.线程控制的基本方法

  

3.2. sleep/join/yield方法介绍

  

sleep方法的应用范例:

package cn.galc.test;

import java.util.*;

public class TestThread3 {
 public static void main(String args[]){
 MyThread thread = new MyThread();
 thread.start();//调用start()方法启动新开辟的线程
 try {
  /*Thread.sleep(10000);
  sleep()方法是在Thread类里面声明的一个静态方法,因此可以使用Thread.sleep()的格式进行调用
  */
  /*MyThread.sleep(10000);
  MyThread类继承了Thread类,自然也继承了sleep()方法,所以也可以使用MyThread.sleep()的格式进行调用
  */
  /*静态方法的调用可以直接使用“类名.静态方法名”
  或者“对象的引用.静态方法名”的方式来调用*/
  MyThread.sleep(10000);
  System.out.println("主线程睡眠了10秒种后再次启动了");
  //在main()方法里面调用另外一个类的静态方法时,需要使用“静态方法所在的类.静态方法名”这种方式来调用
  /*
  所以这里是让主线程睡眠10秒种
  在哪个线程里面调用了sleep()方法就让哪个线程睡眠,所以现在是主线程睡眠了。
  */
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
 thread.flag=false;//改变循环条件,结束死循环
 /**
  * 当发生InterruptedException时,直接把循环的条件设置为false即可退出死循环,
  * 继而结束掉子线程的执行,这是一种比较好的结束子线程的做法
  */
 /**
  * 调用interrupt()方法把正在运行的线程打断
 相当于是主线程一盆凉水泼上去把正在执行分线程打断了
 分线程被打断之后就会抛InterruptedException异常,这样就会执行return语句返回,结束掉线程的执行
 所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
  */
 }
}

class MyThread extends Thread {
 boolean flag = true;// 定义一个标记,用来控制循环的条件

 public void run() {
 /*
  * 注意:这里不能在run()方法的后面直接写throw Exception来抛异常,
  * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
  * 所以这里只能写try……catch()来捕获异常
  */
 while (flag) {
  System.out.println("==========" + new Date().toLocaleString() + "===========");
  try {
  /*
   * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
   */
  // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
  sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
  // 这里是让这个新开辟的线程每隔一秒睡眠一次,然后睡眠一秒钟后再次启动该线程
  // 这里在一个死循环里面每隔一秒启动一次线程,每个一秒打印出当前的系统时间
  } catch (InterruptedException e) {
  /*
   * 睡眠的时一盘冷水泼过来就有可能会打断睡眠
   * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
   */
  return;
  // 线程被中断后就返回,相当于是结束线程
  }
 }
 }
}

运行结果:

 join方法的使用范例:

package cn.galc.test;

public class TestThread4 {
 public static void main(String args[]) {
 MyThread2 thread2 = new MyThread2("mythread");
 // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
 thread2.start();// 启动线程
 try {
  thread2.join();// 调用join()方法合并线程,将子线程mythread合并到主线程里面
  // 合并线程后,程序的执行的过程就相当于是方法的调用的执行过程
 } catch (InterruptedException e) {
  e.printStackTrace();
 }
 for (int i = 0; i <= 5; i++) {
  System.out.println("I am main Thread");
 }
 }
}

class MyThread2 extends Thread {
 MyThread2(String s) {
 super(s);
 /*
  * 使用super关键字调用父类的构造方法
  * 父类Thread的其中一个构造方法:“public Thread(String name)”
  * 通过这样的构造方法可以给新开辟的线程命名,便于管理线程
  */
 }

 public void run() {
 for (int i = 1; i <= 5; i++) {
  System.out.println("I am a\t" + getName());
  // 使用父类Thread里面定义的
  //public final String getName(),Returns this thread's name.
  try {
  sleep(1000);// 让子线程每执行一次就睡眠1秒钟
  } catch (InterruptedException e) {
  return;
  }
 }
 }
}

运行结果:

yield方法的使用范例:

package cn.galc.test;

public class TestThread5 {
 public static void main(String args[]) {
 MyThread3 t1 = new MyThread3("t1");
 /* 同时开辟了两条子线程t1和t2,t1和t2执行的都是run()方法 */
 /* 这个程序的执行过程中总共有3个线程在并行执行,分别为子线程t1和t2以及主线程 */
 MyThread3 t2 = new MyThread3("t2");
 t1.start();// 启动子线程t1
 t2.start();// 启动子线程t2
 for (int i = 0; i <= 5; i++) {
  System.out.println("I am main Thread");
 }
 }
}

class MyThread3 extends Thread {
 MyThread3(String s) {
 super(s);
 }

 public void run() {
 for (int i = 1; i <= 5; i++) {
  System.out.println(getName() + ":" + i);
  if (i % 2 == 0) {
  yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
  /*
   * 在程序的运行的过程中可以看到,
   * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行
   * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
   */
  }
 }
 }
}

运行结果如下:

以上就是本文的全部内容,对java线程进行全面学习,希望可以帮助到大家。

(0)

相关推荐

  • java线程之使用Runnable接口创建线程的方法

    实现Runnable接口的类必须使用Thread类的实例才能创建线程.通过Runnable接口创建线程分为两步: 1. 将实现Runnable接口的类实例化. 2. 建立一个Thread对象,并将第一步实例化后的对象作为参数传入Thread类的构造方法. 最后通过Thread类的start方法建立线程. 下面的代码演示了如何使用Runnable接口来创建线程: 复制代码 代码如下: package mythread; public class MyRunnable implements Runn

  • JAVA中 终止线程的方法介绍

    在Java的多线程编程中,java.lang.Thread类型包含了一些列的方法start(), stop(), stop(Throwable) and suspend(), destroy() and resume().通过这些方法,我们可以对线程进行方便的操作,但是这些方法中,只有start()方法得到了保留. 在Sun公司的一篇文章<Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? >中详细讲解了舍弃这些方

  • java向多线程中传递参数的三种方法详细介绍

    在传统的同步开发模式下,当我们调用一个函数时,通过这个函数的参数将数据传入,并通过这个函数的返回值来返回最终的计算结果.但在多线程的异步开发模式下,数据的传递和返回和同步开发模式有很大的区别.由于线程的运行和结束是不可预料的,因此,在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据.本文就以上原因介绍了几种用于向线程传递数据的方法,在下一篇文章中将介绍从线程中返回数据的方法. 欲先取之,必先予之.一般在使用线程时都需要有一些初始化数据,然后线程利用这些数据进行加工处理,并

  • Java多线程下载的实现方法

    复制代码 代码如下: package cn.me.test; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; /** * 多线程下载 * 1:使用RandomAccessFile在任意的位置写入数据. * 2:需要计算第一个线程下载的数据量,可以平均分配.如果不够平均时, *    则直接最后一个线程处理相对较少

  • Java多线程的用法详解

    1.创建线程 在Java中创建线程有两种方法:使用Thread类和使用Runnable接口.在使用Runnable接口时需要建立一个Thread实例.因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例.Thread构造函数: public Thread( );  public Thread(Runnable target);  public Thread(String name);  public Thread(Runnable target

  • Java线程关闭的3种方法

    Java线程关闭,总的来说有3种: 1.使用状态位,这个简单,就不多说了: 复制代码 代码如下: public class Task extends Thread { private volatile boolean flag= true; public void stopTask() { flag = false; } @Override public void run() { while(flag){ /* do your no-block task */ } } } 2.当线程等待某些事件

  • java 实现线程同步的方式有哪些

    什么是线程同步? 当使用多个线程来访问同一个数据时,非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题. 实现同步机制有两个方法: 1.同步代码块: synchronized(同一个数据){} 同一个数据:就是N条线程同时访问一个数据. 2. 同步方法: public synchronized 数据返回类型 方法名(){} 就是使用 synchronized 来修饰某个方法,则该方法称为同步方法.对于同步方法而言,无需显示指定同步监视器,同步

  • java基本教程之java线程等待与java唤醒线程 java多线程教程

    本章,会对线程等待/唤醒方法进行介绍.涉及到的内容包括:1. wait(), notify(), notifyAll()等方法介绍2. wait()和notify()3. wait(long timeout)和notify()4. wait() 和 notifyAll()5. 为什么notify(), wait()等函数定义在Object中,而不是Thread中 wait(), notify(), notifyAll()等方法介绍在Object.java中,定义了wait(), notify()

  • java基本教程之Thread中start()和run()的区别 java多线程教程

    Thread类包含start()和run()方法,它们的区别是什么?本章将对此作出解答.本章内容包括:start() 和 run()的区别说明start() 和 run()的区别示例start() 和 run()相关源码(基于JDK1.7.0_40) start() 和 run()的区别说明start() : 它的作用是启动一个新线程,新线程会执行相应的run()方法.start()不能被重复调用.run()   : run()就和普通的成员方法一样,可以被重复调用.单独调用run()的话,会在

  • java必学必会之线程(2)

    一.线程的优先级别 线程优先级别的使用范例: package cn.galc.test; public class TestThread6 { public static void main(String args[]) { MyThread4 t4 = new MyThread4(); MyThread5 t5 = new MyThread5(); Thread t1 = new Thread(t4); Thread t2 = new Thread(t5); t1.setPriority(Th

  • java必学必会之线程(1)

    一.线程的基本概念 线程理解:线程是一个程序里面不同的执行路径 每一个分支都叫做一个线程,main()叫做主分支,也叫主线程. 程只是一个静态的概念,机器上的一个.class文件,机器上的一个.exe文件,这个叫做一个进程.程序的执行过程都是这样的:首先把程序的代码放到内存的代码区里面,代码放到代码区后并没有马上开始执行,但这时候说明了一个进程准备开始,进程已经产生了,但还没有开始执行,这就是进程,所以进程其实是一个静态的概念,它本身就不能动.平常所说的进程的执行指的是进程里面主线程开始执行了,

  • java必学必会之方法的重载(overload)

    一.方法的重载 方法名一样,但参数不一样,这就是重载(overload). 所谓的参数不一样,主要有两点:第一是参数的个数不一样,第二是参数的类型不一样.只要这两方面有其中的一方面不一样就可以构成方法的重载了. package cn.galc.test; public class TestOverLoad { void max(int a, int b) { System.out.println(a > b ? a : b); } /* * int max(int a, int b) { * r

  • java必学必会之GUI编程

    一.事件监听 测试代码一: package cn.javastudy.summary; import java.awt.*; import java.awt.event.*; public class TestTextField { public static void main(String args[]) { new MyFrameTextField(); } } class MyFrameTextField extends Frame { MyFrameTextField() { Text

  • java必学必会之网络编程

    一.网络基础概念 首先理清一个概念:网络编程 != 网站编程,网络编程现在一般称为TCP/IP编程. 二.网络通信协议及接口 三.通信协议分层思想 四.参考模型 五.IP协议 每个人的电脑都有一个独一无二的IP地址,这样互相通信时就不会传错信息了. IP地址是用一个点来分成四段的,在计算机内部IP地址是用四个字节来表示的,一个字节代表一段,每一个字节代表的数最大只能到达255. 六.TCP协议和UDP协议 TCP和UDP位于同一层,都是建立在IP层的基础之上.由于两台电脑之间有不同的IP地址,因

  • java必学必会之static关键字

    一.static关键字 原来一个类里面的成员变量,每new一个对象,这个对象就有一份自己的成员变量,因为这些成员变量都不是静态成员变量.对于static成员变量来说,这个成员变量只有一份,而且这一份是这个类所有的对象共享. 1.1.静态成员变量与非静态成员变量的区别 以下面的例子为例说明 package cn.galc.test; public class Cat { /** * 静态成员变量 */ private static int sid = 0; private String name;

  • java必学必会之this关键字

    一.this关键字 this是一个引用,它指向自身的这个对象. 看内存分析图: 假设我们在堆内存new了一个对象,在这个对象里面你想象着他有一个引用this,this指向这个对象自己,所以这就是this,这个new出来的对象名字是什么,我们不知道,不知道也没关系,因为这并不影响这个对象在内存里面的存在,这个对象只要在内存中存在,他就一定有一个引用this. 看下面的例子分析: package cn.galc.test; public class Leaf { int i = 0; public

  • java必学必会之equals方法

    一.equals方法介绍 1.1.通过下面的例子掌握equals的用法 package cn.galc.test; public class TestEquals { public static void main(String[] args) { /** * 这里使用构造方法Cat()在堆内存里面new出了两只猫, * 这两只猫的color,weight,height都是一样的, * 但c1和c2却永远不会相等,这是因为c1和c2分别为堆内存里面两只猫的引用对象, * 里面装着可以找到这两只猫

  • 新手小白入门必学JAVA面向对象之多态

    目录 1. 概念 2 . 特点 3. 练习:多态入门案例 4. 多态的好处 5. 多态的使用 6. 练习:多态成员使用测试 7 拓展 7.1 设计汽车综合案例 7.2 多态为了统一调用标准 7.3 静态变量和实例变量的区别 7.4 向上转型和向下转型 总结 1. 概念 多态是面向对象程序设计(OOP)的一个重要特征,指同一个实体同时具有多种形式,即同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态. 可以把不同的子类对象都当作父类来看,进而屏蔽不同子类对象之间的差异,写出通用的代码,

  • Java线程池必知必会知识点总结

    目录 1.线程数使用开发规约 2.ThreadPoolExecutor源码 1.构造函数 2.核心参数 3.execute()方法 3.线程池的工作流程 4.Executors创建返回ThreadPoolExecutor对象(不推荐) 1.Executors#newCachedThreadPool=>创建可缓存的线程池 2.Executors#newSingleThreadExecutor=>创建单线程的线程池 3.Executors#newFixedThreadPool=>创建固定长度

随机推荐