(二)java多线程实例（转）

一、线程的生命周期

线程状态转换图：

img

1、新建状态

用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（runnable）。

注意：不能对已经启动的线程再次调用start()方法，否则会出现Java.lang.IllegalThreadStateException异常。

2、就绪状态

处于就绪状态的线程已经具备了运行条件，但还没有分配到CPU，处于线程就绪队列（尽管是采用队列形式，事实上，把它称为可运行池而不是可运行队列。因为cpu的调度不一定是按照先进先出的顺序来调度的），等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态，系统挑选的动作称之为“cpu调度”。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。

提示：如果希望子线程调用start()方法后立即执行，可以使用Thread.sleep()方式使主线程睡眠一伙儿，转去执行子线程。

3、运行状态

处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。****

处于就绪状态的线程，如果获得了cpu的调度，就会从就绪状态变为运行状态，执行run()方法中的任务。如果该线程失去了cpu资源，就会又从运行状态变为就绪状态。重新等待系统分配资源。也可以对在运行状态的线程调用yield()方法，它就会让出cpu资源，再次变为就绪状态。

当发生如下情况是，线程会从运行状态变为阻塞状态：

①、线程调用sleep方法主动放弃所占用的系统资源

②、线程调用一个阻塞式IO方法，在该方法返回之前，该线程被阻塞

③、线程试图获得一个同步监视器，但更改同步监视器正被其他线程所持有

④、线程在等待某个通知（notify）

⑤、程序调用了线程的suspend方法将线程挂起。不过该方法容易导致死锁，所以程序应该尽量避免使用该方法。

当线程的run()方法执行完，或者被强制性地终止，例如出现异常，或者调用了stop()、desyory()方法等等，就会从运行状态转变为死亡状态。

4、阻塞状态

处于运行状态的线程在某些情况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时停止自己的运行，进入阻塞状态。

在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的I/O设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。有三种方法可以暂停Threads执行：

5、死亡状态

当线程的run()方法执行完，或者被强制性地终止，就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

二、线程状态的控制

Java提供了一些便捷的方法用于会线程状态的控制。 .

void	**destroy**() 已过时。 该方法最初用于破坏该线程，但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	**interrupt**() 中断线程。
void	**join**() 等待该线程终止。
void	**join**(long millis) 等待该线程终止的时间最长为 millis 毫秒。
void	**join**(long millis, int nanos) 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
void	**resume**() 已过时。 该方法只与 suspend() 一起使用，但 suspend() 已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	**setDaemon**(boolean on) 将该线程标记为守护线程或用户线程。
void	**setPriority**(int newPriority) 更改线程的优先级。
static void	**sleep**(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
static void	**sleep**(long millis, int nanos) 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
void	**start**() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void	**stop**() 已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查ThreadDeath 异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用interrupt 方法来中断该等待。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	**stop**(Throwable obj) 已过时。 该方法具有固有的不安全性。有关详细信息，请参阅 stop()。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
void	**suspend**() 已过时。 该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用resume 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume？。
static void	**yield**() 暂停当前正在执行的线程对象，并执行其他线程。

可以看到很多方法，已经标注为过时的，我们应该尽可能的避免使用它们，而应该重点关注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setDaemon()、setPriority()等间接控制方法。

1、线程睡眠——sleep

如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread的sleep方法，从上面可以看到sleep方法有两种重载的形式，但是使用方法一样。

比如，我们想要使主线程每休眠100毫秒，然后再打印出数字：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         for(int i=0;i<100;i++){  
4.             System.out.println("main"+i);  
5.             Thread.sleep(100);  
6.         }  
7.     }  
8. }  

可以明显看到打印的数字在时间上有些许的间隔。

注意如下几点问题

①、sleep是静态方法，最好不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。看下面的例子：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         System.out.println(Thread.currentThread().getName());  
4.         MyThread myThread=new MyThread();  
5.         myThread.start();  
6.         myThread.sleep(1000);//这里sleep的就是main线程，而非myThread线程  
7.         Thread.sleep(10);  
8.         for(int i=0;i<100;i++){  
9.             System.out.println("main"+i);  
10.         }  
11.     }  
12. }  

②、Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         new MyThread().start();  
4.         new MyThread().start();  
5.     }  
6. }  
7.   
8. class MyThread extends Thread {  
9.     @Override  
10.     public void run() {  
11.         for (int i = 0; i < 3; i++) {  
12.             System.out.println(this.getName()+"线程" + i + "次执行！");  
13.             try {  
14.                 Thread.sleep(50);  
15.             } catch (InterruptedException e) {  
16.                 e.printStackTrace();  
17.             }  
18.         }  
19.     }  
20. }  

看某一次的运行结果:

1. Thread-0线程0次执行！
2. Thread-1线程0次执行！
3. Thread-1线程1次执行！
4. Thread-0线程1次执行！
5. Thread-0线程2次执行！
6. Thread-1线程2次执行！

可以看到，线程0首先执行，然后线程1执行一次，又了执行一次。可以看到它并不是按照sleep的顺序执行的。

2、线程让步——yield

yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态的方法，它也可以让当前正在执行的线程暂停，让出cpu资源给其他的线程。但是和sleep()方法不同的是，它不会进入到阻塞状态，而是进入到就绪状态。yield()方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。

实际上，当某个线程调用了yield()方法暂停之后，优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会，当然，只是有可能，因为我们不可能精确的干涉cpu调度线程。

yield的用法：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         new MyThread("低级", 1).start();  
4.         new MyThread("中级", 5).start();  
5.         new MyThread("高级", 10).start();  
6.     }  
7. }  
8.   
9. class MyThread extends Thread {  
10.     public MyThread(String name, int pro) {  
11.         super(name);// 设置线程的名称  
12.         this.setPriority(pro);// 设置优先级  
13.     }  
14.   
15.     @Override  
16.     public void run() {  
17.         for (int i = 0; i < 30; i++) {  
18.             System.out.println(this.getName() + "线程第" + i + "次执行！");  
19.             if (i % 5 == 0)  
20.                 Thread.yield();  
21.         }  
22.     }  
23. }  

关于sleep()方法和yield()方的区别如下:

1. sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。
2. sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。
3. sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。

3、线程合并——join

线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时，Thread类提供了join方法来完成这个功能，注意，它不是静态方法。
从上面的方法的列表可以看到，它有3个重载的方法：
void join()
​ 当前线程等该加入该线程后面，等待该线程终止。
void join(long millis)
​ 当前线程等待该线程终止的时间最长为 millis 毫秒。 如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
void join(long millis,int nanos)
​ 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度

例子：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         MyThread thread=new MyThread();  
4.         thread.start();  
5.         thread.join(1);//将主线程加入到子线程后面，不过如果子线程在1毫秒时间内没执行完，则主线程便不再等待它执行完，进入就绪状态，等待cpu调度  
6.         for(int i=0;i<30;i++){  
7.             System.out.println(Thread.currentThread().getName() + "线程第" + i + "次执行！");  
8.         }  
9.     }  
10. }  
11.   
12. class MyThread extends Thread {  
13.     @Override  
14.     public void run() {  
15.         for (int i = 0; i < 1000; i++) {  
16.             System.out.println(this.getName() + "线程第" + i + "次执行！");  
17.         }  
18.     }  
19. }

在这个例子中，在主线程中调用thread.join(); 就是将主线程加入到thread子线程后面等待执行。不过有时间限制，为1毫秒。

4、线程的优先级

每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。

每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。

Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~·0之间，也可以使用Thread类提供的三个静态常量：

MAX_PRIORITY =10

MIN_PRIORITY =1

NORM_PRIORITY =5

例子：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         new MyThread("高级", 10).start();  
4.         new MyThread("低级", 1).start();  
5.     }  
6. }  
7.   
8. class MyThread extends Thread {  
9.     public MyThread(String name,int pro) {  
10.         super(name);//设置线程的名称  
11.         setPriority(pro);//设置线程的优先级  
12.     }  
13.     @Override  
14.     public void run() {  
15.         for (int i = 0; i < 100; i++) {  
16.             System.out.println(this.getName() + "线程第" + i + "次执行！");  
17.         }  
18.     }  
19. }  

从结果可以看到 ，一般情况下，高级线程更显执行完毕。

注意一点：虽然Java提供了10个优先级别，但这些优先级别需要操作系统的支持。不同的操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级别对应。所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级，这样才能保证程序最好的可移植性。

5、守护线程

守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。

守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。

1. /** 
2. * Java线程：线程的调度-守护线程 
3. */  
4. public class Test {  
5.         public static void main(String[] args) {  
6.                 Thread t1 = new MyCommon();  
7.                 Thread t2 = new Thread(new MyDaemon());  
8.                 t2.setDaemon(true);        //设置为守护线程  
9.   
10.                 t2.start();  
11.                 t1.start();  
12.         }  
13. }  
14.   
15. class MyCommon extends Thread {  
16.         public void run() {  
17.                 for (int i = 0; i < 5; i++) {  
18.                         System.out.println("线程1第" + i + "次执行！");  
19.                         try {  
20.                                 Thread.sleep(7);  
21.                         } catch (InterruptedException e) {  
22.                                 e.printStackTrace();  
23.                         }  
24.                 }  
25.         }  
26. }  
27.   
28. class MyDaemon implements Runnable {  
29.         public void run() {  
30.                 for (long i = 0; i < 9999999L; i++) {  
31.                         System.out.println("后台线程第" + i + "次执行！");  
32.                         try {  
33.                                 Thread.sleep(7);  
34.                         } catch (InterruptedException e) {  
35.                                 e.printStackTrace();  
36.                         }  
37.                 }  
38.         }  
39. }  

1. 后台线程第0次执行！
2. 线程1第0次执行！
3. 线程1第1次执行！
4. 后台线程第1次执行！
5. 后台线程第2次执行！
6. 线程1第2次执行！
7. 线程1第3次执行！
8. 后台线程第3次执行！
9. 线程1第4次执行！
10. 后台线程第4次执行！
11. 后台线程第5次执行！
12. 后台线程第6次执行！
13. 后台线程第7次执行！

从上面的执行结果可以看出：前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。

实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。

守护线程的用途：

守护线程通常用于执行一些后台作业，例如在你的应用程序运行时播放背景音乐，在文字编辑器里做自动语法检查、自动保存等功能。Java的垃圾回收也是一个守护线程。守护线

的好处就是你不需要关心它的结束问题。例如你在你的应用程序运行的时候希望播放背景音乐，如果将这个播放背景音乐的线程设定为非守护线程，那么在用户请求退出的时候，

不仅要退出主线程，还要通知播放背景音乐的线程退出；如果设定为守护线程则不需要了。

6、如何结束一个线程

Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了，使用它们是极端不安全的！想要安全有效的结束一个线程，可以使用下面的方法。

1、正常执行完run方法，然后结束掉

2、控制循环条件和判断条件的标识符来结束掉线程

比如说run方法这样写：

1. class MyThread extends Thread {  
2.     int i=0;  
3.     @Override  
4.     public void run() {  
5.         while (true) {  
6.             if(i==10)  
7.                 break;  
8.             i++;  
9.             System.out.println(i);  
10.               
11.         }  
12.     }  
13. }  

或者

1. class MyThread extends Thread {  
2.     int i=0;  
3.     boolean next=true;  
4.     @Override  
5.     public void run() {  
6.         while (next) {  
7.             if(i==10)  
8.                 next=false;  
9.             i++;  
10.             System.out.println(i);  
11.         }  
12.     }  
13. }  

或者

1. class MyThread extends Thread {  
2.     int i=0;  
3.     @Override  
4.     public void run() {  
5.         while (true) {  
6.             if(i==10)  
7.                 return;  
8.             i++;  
9.             System.out.println(i);  
10.         }  
11.     }  
12. }  

只要保证在一定的情况下，run方法能够执行完毕即可。而不是while(true)的无线循环。

3、使用interrupt结束一个线程。

诚然，使用第2中方法的标识符来结束一个线程，是一个不错的方法，但是如果，该线程是处于sleep、wait、join的状态的时候，while循环就不会执行，那么我们的标识符就无用武之地了，当然也不能再通过它来结束处于这3种状态的线程了。

可以使用interrupt这个巧妙的方式结束掉这个线程。

我们看看sleep、wait、join方法的声明：

public final void wait() throws InterruptedException

public static native void sleep(long millis) throws InterruptedException

public final void join() throws InterruptedException

可以看到，这三者有一个共同点，都抛出了一个InterruptedException的异常。
在什么时候会产生这样一个异常呢？
每个Thread都有一个中断状状态，默认为false。可以通过Thread对象的isInterrupted()方法来判断该线程的中断状态。可以通过Thread对象的interrupt()方法将中断状态设置为true。
当一个线程处于sleep、wait、join这三种状态之一的时候，如果此时他的中断状态为true，那么它就会抛出一个InterruptedException的异常，并将中断状态重新设置为false。
看下面的简单的例子：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         MyThread thread=new MyThread();  
4.         thread.start();  
5.     }  
6. }  
7. 
8. class MyThread extends Thread {  
9.     int i=1;  
10.     @Override  
11.     public void run() {  
12.         while (true) {  
13.             System.out.println(i);  
14.             System.out.println(this.isInterrupted());  
15.             try {  
16.                 System.out.println("我马上去sleep了");  
17.                 Thread.sleep(2000);  
18.                 this.interrupt();  
19.             } catch (InterruptedException e) {  
20.                 System.out.println("异常捕获了"+this.isInterrupted());  
21.                 return;  
22.             }  
23.             i++;  
24.         }  
25.     }  
26. }  

测试结果：

1. 1
2. false
3. 我马上去sleep了
4. 2
5. true
6. 我马上去sleep了
7. 异常捕获了false

可以看到，首先执行第一次while循环，在第一次循环中，睡眠2秒，然后将中断状态设置为true。当进入到第二次循环的时候，中断状态就是第一次设置的true，当它再次进入sleep的时候，马上就抛出了InterruptedException异常，然后被我们捕获了。然后中断状态又被重新自动设置为false了（从最后一条输出可以看出来）。

所以，我们可以使用interrupt方法结束一个线程。具体使用如下：

1. public class Test1 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         MyThread thread=new MyThread();  
4.         thread.start();  
5.         Thread.sleep(3000);  
6.         thread.interrupt();  
7.     }  
8. }  
9. 
10. class MyThread extends Thread {  
11.     int i=0;  
12.     @Override  
13.     public void run() {  
14.         while (true) {  
15.             System.out.println(i);  
16.             try {  
17.                 Thread.sleep(1000);  
18.             } catch (InterruptedException e) {  
19.                 System.out.println("中断异常被捕获了");  
20.                 return;  
21.             }  
22.             i++;  
23.         }  
24.     }  
25. }

多测试几次，会发现一般有两种执行结果：

1. 0
2. 1
3. 2
4. 中断异常被捕获了
   或者
5. 0
6. 1
7. 2
8. 3
9. 中断异常被捕获了

这两种结果恰恰说明了 只要一个线程的中断状态一旦为true，只要它进入sleep等状态，或者处于sleep状态，立马回抛出InterruptedException异常。

第一种情况，是当主线程从3秒睡眠状态醒来之后，调用了子线程的interrupt方法，此时子线程正处于sleep状态，立马抛出InterruptedException异常。

第一种情况，是当主线程从3秒睡眠状态醒来之后，调用了子线程的interrupt方法，此时子线程还没有处于sleep状态。然后再第3次while循环的时候，在此进入sleep状态，立马抛出InterruptedException异常。