共计 4679 个字符，预计需要花费 12 分钟才能阅读完成。
一、线程状态
线程的状态转换是线程管制的根底。线程状态总的可分为五大状态：别离是生、死、可运行、运行、期待 / 阻塞。用一个图来形容如下：
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 个数字输入一个字符串
*
- @author leizhimin 2008-9-14 9:53:49
*/
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() 对线程栈导致的后果是线程栈产生了变动，当然这些变动都是刹时的。
小结
到目前地位，介绍了线程来到运行状态的 3 种办法：
1、调用 Thread.sleep()：使以后线程睡眠至多多少毫秒（只管它可能在指定的工夫之前被中断）。
2、调用 Thread.yield()：不能保障太多事件，只管通常它会让以后运行线程回到可运行性状态，使得有雷同优先级的线程有机会执行。
3、调用 join() 办法：保障以后线程进行执行，直到该线程所退出的线程实现为止。然而，如果它退出的线程没有存活，则以后线程不须要进行。
除了以上三种形式外，还有上面几种非凡状况可能使线程来到运行状态：
1、线程的 run() 办法实现。
2、在对象上调用 wait() 办法（不是在线程上调用）。
3、线程不能在对象上取得锁定，它正试图运行该对象的办法代码。
4、线程调度程序能够决定将以后运行状态挪动到可运行状态，以便让另一个线程取得运行机会，而不须要任何理由。
