java-多线程004

Java线程：线程状态的转换

 

一、线程状态

 

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：

 

1、新状态：线程对象已经创建，还没有在其上调用start()方法。

 

2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

 

3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

 

4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。

 

5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

 

有关详细状态转换图可以参看本人的“Java多线程编程总结”中的图

 

二、阻止线程执行

对于线程的阻止，考虑一下三个方面，不考虑IO阻塞的情况：

睡眠；

等待；

因为需要一个对象的锁定而被阻塞。

 

1、睡眠

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态。

 

线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

 

睡眠的实现：调用静态方法。

        try {
            Thread.sleep(123);
        } catch (InterruptedException e) {
            e.printStackTrace();  
        }

 

睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。

 

例如，在前面的例子中，将一个耗时的操作改为睡眠，以减慢线程的执行。可以这么写：

 

    public void run() {
        for(int i = 0;i<5;i++){

// 很耗时的操作，用来减慢线程的执行
//            for(long k= 0; k <100000000;k++);
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();  .
            }
            System.out.println(this.getName()+" :"+i);
        }
    }

 

运行结果：

阿三 :0 
李四 :0 
阿三 :1 
阿三 :2 
阿三 :3 
李四 :1 
李四 :2 
阿三 :4 
李四 :3 
李四 :4 

Process finished with exit code 0

 

这样，线程在每次执行过程中，总会睡眠3毫秒，睡眠了，其他的线程就有机会执行了。

 

注意：

1、线程睡眠是帮助所有线程获得运行机会的最好方法。

2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

3、sleep()是静态方法，只能控制当前正在运行的线程。

 

下面给个例子：

/** 
* 一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串 
* 
*/ 
public class MyThread extends Thread { 

    public void run() { 
        for (int i = 0; i < 100; i++) { 
            if ((i) % 10 == 0) { 
                System.out.println("-------" + i); 
            } 
            System.out.print(i); 
            try { 
                Thread.sleep(1); 
                System.out.print("    线程睡眠1毫秒！\n"); 
            } catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 

    public static void main(String[] args) { 
        new MyThread().start(); 
    } 
} 

 

-------0 
0    线程睡眠1毫秒！ 
1    线程睡眠1毫秒！ 
2    线程睡眠1毫秒！ 
3    线程睡眠1毫秒！ 
4    线程睡眠1毫秒！ 
5    线程睡眠1毫秒！ 
6    线程睡眠1毫秒！ 
7    线程睡眠1毫秒！ 
8    线程睡眠1毫秒！ 
9    线程睡眠1毫秒！ 
-------10 
10    线程睡眠1毫秒！ 
11    线程睡眠1毫秒！ 
12    线程睡眠1毫秒！ 
13    线程睡眠1毫秒！ 
14    线程睡眠1毫秒！ 
15    线程睡眠1毫秒！ 
16    线程睡眠1毫秒！ 
17    线程睡眠1毫秒！ 
18    线程睡眠1毫秒！ 
19    线程睡眠1毫秒！ 
-------20 
20    线程睡眠1毫秒！ 
21    线程睡眠1毫秒！ 
22    线程睡眠1毫秒！ 
23    线程睡眠1毫秒！ 
24    线程睡眠1毫秒！ 
25    线程睡眠1毫秒！ 
26    线程睡眠1毫秒！ 
27    线程睡眠1毫秒！ 
28    线程睡眠1毫秒！ 
29    线程睡眠1毫秒！ 
-------30 
30    线程睡眠1毫秒！ 
31    线程睡眠1毫秒！ 
32    线程睡眠1毫秒！ 
33    线程睡眠1毫秒！ 
34    线程睡眠1毫秒！ 
35    线程睡眠1毫秒！ 
36    线程睡眠1毫秒！ 
37    线程睡眠1毫秒！ 
38    线程睡眠1毫秒！ 
39    线程睡眠1毫秒！ 
-------40 
40    线程睡眠1毫秒！ 
41    线程睡眠1毫秒！ 
42    线程睡眠1毫秒！ 
43    线程睡眠1毫秒！ 
44    线程睡眠1毫秒！ 
45    线程睡眠1毫秒！ 
46    线程睡眠1毫秒！ 
47    线程睡眠1毫秒！ 
48    线程睡眠1毫秒！ 
49    线程睡眠1毫秒！ 
-------50 
50    线程睡眠1毫秒！ 
51    线程睡眠1毫秒！ 
52    线程睡眠1毫秒！ 
53    线程睡眠1毫秒！ 
54    线程睡眠1毫秒！ 
55    线程睡眠1毫秒！ 
56    线程睡眠1毫秒！ 
57    线程睡眠1毫秒！ 
58    线程睡眠1毫秒！ 
59    线程睡眠1毫秒！ 
-------60 
60    线程睡眠1毫秒！ 
61    线程睡眠1毫秒！ 
62    线程睡眠1毫秒！ 
63    线程睡眠1毫秒！ 
64    线程睡眠1毫秒！ 
65    线程睡眠1毫秒！ 
66    线程睡眠1毫秒！ 
67    线程睡眠1毫秒！ 
68    线程睡眠1毫秒！ 
69    线程睡眠1毫秒！ 
-------70 
70    线程睡眠1毫秒！ 
71    线程睡眠1毫秒！ 
72    线程睡眠1毫秒！ 
73    线程睡眠1毫秒！ 
74    线程睡眠1毫秒！ 
75    线程睡眠1毫秒！ 
76    线程睡眠1毫秒！ 
77    线程睡眠1毫秒！ 
78    线程睡眠1毫秒！ 
79    线程睡眠1毫秒！ 
-------80 
80    线程睡眠1毫秒！ 
81    线程睡眠1毫秒！ 
82    线程睡眠1毫秒！ 
83    线程睡眠1毫秒！ 
84    线程睡眠1毫秒！ 
85    线程睡眠1毫秒！ 
86    线程睡眠1毫秒！ 
87    线程睡眠1毫秒！ 
88    线程睡眠1毫秒！ 
89    线程睡眠1毫秒！ 
-------90 
90    线程睡眠1毫秒！ 
91    线程睡眠1毫秒！ 
92    线程睡眠1毫秒！ 
93    线程睡眠1毫秒！ 
94    线程睡眠1毫秒！ 
95    线程睡眠1毫秒！ 
96    线程睡眠1毫秒！ 
97    线程睡眠1毫秒！ 
98    线程睡眠1毫秒！ 
99    线程睡眠1毫秒！ 

Process finished with exit code 0 

2、线程的优先级和线程让步yield()

线程的让步是通过Thread.yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

 

要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

 

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

 

当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

 

设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：

        Thread t = new MyThread();
        t.setPriority(8);
        t.start();

线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。

 

线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：

static int MAX_PRIORITY 
          线程可以具有的最高优先级。 
static int MIN_PRIORITY 
          线程可以具有的最低优先级。 
static int NORM_PRIORITY 
          分配给线程的默认优先级。

 

3、Thread.yield()方法

 

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

 

4、join()方法

 

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：

        Thread t = new MyThread();
        t.start();
        t.join();

另外，join()方法还有带超时限制的重载版本。 例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

 

线程的加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：

 

 public class JoinThread extends Thread{

     public JoinThread(String name){
           super(name);
     }
     
     public void run(){
           for(int i=0; i<10; i＋＋){
                 for(long k=0; k<100000000; k＋＋){}

                 System.out.println(this.getName() ＋ ": " ＋ i);
           }
     }
     
     public static void main(String[] args){
           Thread t1 = new JoinThread("AA AA");
           t1.start();
           try{
                 t1.join(1000);                 //Join在这里~
           } catch(InterruptedException e) {
                 e.printStackTrace();
           }      
           System.out.println("over");
     }
}

然后输出的结果是：
AA AA: 0
AA AA: 1
over
AA AA: 2
AA AA: 3
AA AA: 4
AA AA: 5
AA AA: 6
AA AA: 7
AA AA: 8
AA AA: 9

但是如果把 t.join(1000) 改成 t.join() 的话输出结果会变成：
AA AA: 0
AA AA: 1
AA AA: 2
AA AA: 3
AA AA: 4
AA AA: 5
AA AA: 6
AA AA: 7
AA AA: 8
AA AA: 9
over

这样子就很明显了，t.join(int wait_time);后面的代码想要执行需要满足以下条件之一：
1、线程t死了；
2、等待时间超过wait_time；

如果没有指定wait_time就只能等线程t死了才行了···

hread.join();后是不是指暂停主线程，优先运行thread，当thread线程结束后，再继续主线程？
ps：我在调用thread.join之前启动的线程b，在执行完thread.join()后，b线程不受影响，继续执行，受影响的只是主线程

我感觉 join() 理解成 强行抢占资源 比较好 我觉得发生机制 在栈空间里 就像楼主画的图那样 谁调用join()谁抢占资源 先运行 要么运行完 要么设置占用资源时间

 

小结

到目前位置，介绍了线程离开运行状态的3种方法：

1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。

2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

 

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：

1、线程的run()方法完成。

2、在对象上调用wait()方法（不是在线程上调用）。

3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。

4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。