一、線程的生命周期
線程狀態轉換圖：
1、新建狀態
用new關鍵字和thread類或其子類建立一個線程對象后，該線程對象就處于新生狀態。處于新生狀態的線程有自己的內存空間，通過調用start方法進入就緒狀態（runnable）。
注意：不能對已經啟動的線程再次調用start()方法，否則會出現javalang.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設備空閑下來，線程便轉入就緒狀態，重新到就緒隊列中排隊等待，被系統選中后從原來停止的位置開始繼續運行。
5、死亡狀態
當線程的run()方法執行完，或者被強制性地終止，就認為它死去。這個線程對象也許是活的，但是，它已經不是一個單獨執行的線程。線程一旦死亡，就不能復生。 如果在一個死去的線程上調用start()方法，會拋出java.lang.illegalthreadstateexception異常。
二、線程狀態的控制
java提供了一些便捷的方法用于會線程狀態的控制。
.
可以看到很多方法，已經標注為過時的，我們應該盡可能的避免使用它們，而應該重點關注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setdaemon()、setpriority()等間接控制方法。
1、線程睡眠——sleep
如果我們需要讓當前正在執行的線程暫停一段時間，并進入阻塞狀態，則可以通過調用thread的sleep方法，從上面可以看到sleep方法有兩種重載的形式，但是使用方法一樣。
比如，我們想要使主線程每休眠100毫秒，然后再打印出數字：
|
1
2
3
4
5
6
7
8
|
public class test { public static void main(string[] args) throws interruptedexception { for(int i=;i<;i++){ system.out.println("main"+i); thread.sleep(); } } } |
可以明顯看到打印的數字在時間上有些許的間隔。
注意如下幾點問題
①、sleep是靜態方法，最好不要用thread的實例對象調用它，因為它睡眠的始終是當前正在運行的線程，而不是調用它的線程對象，它只對正在運行狀態的線程對象有效。看下面的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class test1 { public static void main(string[] args) throws interruptedexception { system.out.println(thread.currentthread().getname()); mythread mythread=new mythread(); mythread.start(); mythread.sleep(1000);//這里sleep的就是main線程，而非mythread線程 thread.sleep(10); for(int i=0;i<100;i++){ system.out.println("main"+i); } } } |
②、java線程調度是java多線程的核心，只有良好的調度，才能充分發揮系統的性能，提高程序的執行效率。但是不管程序員怎么編寫調度，只能最大限度的影響線程執行的次序，而不能做到精準控制。因為使用sleep方法之后，線程是進入阻塞狀態的，只有當睡眠的時間結束，才會重新進入到就緒狀態，而就緒狀態進入到運行狀態，是由系統控制的，我們不可能精準的去干涉它，所以如果調用thread.sleep(1000)使得線程睡眠1秒，可能結果會大于1秒。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class test1 { public static void main(string[] args) throws interruptedexception { new mythread().start(); new mythread().start(); } } class mythread extends thread { @override public void run() { for (int i = 0; i < 3; i++) { system.out.println(this.getname()+"線程" + i + "次執行！"); try { thread.sleep(50); } catch (interruptedexception e) { e.printstacktrace(); } } } } |
看某一次的運行結果：
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class test1 { public static void main(string[] args) throws interruptedexception { new mythread("低級", 1).start(); new mythread("中級", 5).start(); new mythread("高級", 10).start(); } } class mythread extends thread { public mythread(string name, int pro) { super(name);// 設置線程的名稱 this.setpriority(pro);// 設置優先級 } @override public void run() { for (int i = 0; i < 30; i++) { system.out.println(this.getname() + "線程第" + i + "次執行！"); if (i % 5 == 0) thread.yield(); } } } |
關于sleep()方法和yield()方的區別如下：
①、sleep方法暫停當前線程后，會進入阻塞狀態，只有當睡眠時間到了，才會轉入就緒狀態。而yield方法調用后 ，是直接進入就緒狀態，所以有可能剛進入就緒狀態，又被調度到運行狀態。
②、sleep方法聲明拋出了interruptedexception，所以調用sleep方法的時候要捕獲該異常，或者顯示聲明拋出該異常。而yield方法則沒有聲明拋出任務異常。
③、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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); thread.join(1);//將主線程加入到子線程后面，不過如果子線程在1毫秒時間內沒執行完，則主線程便不再等待它執行完，進入就緒狀態，等待cpu調度 for(int i=0;i<30;i++){ system.out.println(thread.currentthread().getname() + "線程第" + i + "次執行！"); } } } class mythread extends thread { @overridepublic void run() { for (int i = 0; i < 1000; i++) { system.out.println(this.getname() + "線程第" + i + "次執行！"); } } } |
在這個例子中，在主線程中調用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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class test1 { public static void main(string[] args) throws interruptedexception { new mythread("高級", 10).start(); new mythread("低級", 1).start(); } } class mythread extends thread { public mythread(string name,int pro) { super(name);//設置線程的名稱 setpriority(pro);//設置線程的優先級 } @override public void run() { for (int i = 0; i < 100; i++) { system.out.println(this.getname() + "線程第" + i + "次執行！"); } } } |
從結果可以看到 ，一般情況下，高級線程更顯執行完畢。
注意一點：雖然java提供了10個優先級別，但這些優先級別需要操作系統的支持。不同的操作系統的優先級并不相同，而且也不能很好的和java的10個優先級別對應。所以我們應該使用max_priority、min_priority和norm_priority三個靜態常量來設定優先級，這樣才能保證程序最好的可移植性。
5、守護線程
守護線程與普通線程寫法上基本么啥區別，調用線程對象的方法setdaemon(true)，則可以將其設置為守護線程。
守護線程使用的情況較少，但并非無用，舉例來說，jvm的垃圾回收、內存管理等線程都是守護線程。還有就是在做數據庫應用時候，使用的數據庫連接池，連接池本身也包含著很多后臺線程，監控連接個數、超時時間、狀態等等。
setdaemon方法的詳細說明：
public final void setdaemon(boolean on)將該線程標記為守護線程或用戶線程。當正在運行的線程都是守護線程時，java 虛擬機退出。
該方法必須在啟動線程前調用。 該方法首先調用該線程的 checkaccess 方法，且不帶任何參數。這可能拋出 securityexception（在當前線程中）。
參數：
on - 如果為 true，則將該線程標記為守護線程。
拋出：
illegalthreadstateexception - 如果該線程處于活動狀態。
securityexception - 如果當前線程無法修改該線程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
/** * java線程：線程的調度-守護線程 */public class test { public static void main(string[] args) { thread t1 = new mycommon(); thread t2 = new thread(new mydaemon()); t2.setdaemon(true); //設置為守護線程 t2.start(); t1.start(); } } class mycommon extends thread { public void run() { for (int i = 0; i < 5; i++) { system.out.println("線程1第" + i + "次執行！"); try { thread.sleep(7); } catch (interruptedexception e) { e.printstacktrace(); } } } } class mydaemon implements runnable { public void run() { for (long i = 0; i < 9999999l; i++) { system.out.println("后臺線程第" + i + "次執行！"); try { thread.sleep(7); } catch (interruptedexception e) { e.printstacktrace(); } } } } |
執行結果：
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
2
3
4
5
6
7
8
9
10
11
12
13
|
class mythread extends thread { int i=0; @override public void run() { while (true) { if(i==10) break; i++; system.out.println(i); } } } |
或者
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
class mythread extends thread { int i=0; boolean next=true; @override public void run() { while (next) { if(i==10) next=false; i++; system.out.println(i); } } } |
或者
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class mythread extends thread { int i=0; @override public void run() { while (true) { if(i==10) return; i++; system.out.println(i); } } } |
只要保證在一定的情況下，run方法能夠執行完畢即可。而不是while(true)的無線循環。
3、使用interrupt結束一個線程。
誠然，使用第2中方法的標識符來結束一個線程，是一個不錯的方法，但是如果，該線程是處于sleep、wait、join的狀態的時候，while循環就不會執行，那么我們的標識符就無用武之地了，當然也不能再通過它來結束處于這3種狀態的線程了。
可以使用interrupt這個巧妙的方式結束掉這個線程。
我們看看sleep、wait、join方法的聲明：
|
1
2
3
|
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); } } class mythread extends thread { int i=1; @override public void run() { while (true) { system.out.println(i); system.out.println(this.isinterrupted()); try { system.out.println("我馬上去sleep了"); thread.sleep(2000); this.interrupt(); } catch (interruptedexception e) { system.out.println("異常捕獲了"+this.isinterrupted()); return; } i++; } } } |
測試結果：
1. 1
2. false
3. 我馬上去sleep了
4. 2
5. true
6. 我馬上去sleep了
7. 異常捕獲了false
可以看到，首先執行第一次while循環，在第一次循環中，睡眠2秒，然后將中斷狀態設置為true。當進入到第二次循環的時候，中斷狀態就是第一次設置的true，當它再次進入sleep的時候，馬上就拋出了interruptedexception異常，然后被我們捕獲了。然后中斷狀態又被重新自動設置為false了（從最后一條輸出可以看出來）。
所以，我們可以使用interrupt方法結束一個線程。具體使用如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public class test1 { public static void main(string[] args) throws interruptedexception { mythread thread=new mythread(); thread.start(); thread.sleep(3000); thread.interrupt(); } } class mythread extends thread { int i=0; @override public void run() { while (true) { system.out.println(i); try { thread.sleep(1000); } catch (interruptedexception e) { system.out.println("中斷異常被捕獲了"); return; } i++; } } } |
多測試幾次，會發現一般有兩種執行結果：
0
1
2
4. 中斷異常被捕獲了
或者
0
1
2
3
5. 中斷異常被捕獲了
這兩種結果恰恰說明了 只要一個線程的中斷狀態一旦為true，只要它進入sleep等狀態，或者處于sleep狀態，立馬回拋出interruptedexception異常。
第一種情況，是當主線程從3秒睡眠狀態醒來之后，調用了子線程的interrupt方法，此時子線程正處于sleep狀態，立馬拋出interruptedexception異常。
第一種情況，是當主線程從3秒睡眠狀態醒來之后，調用了子線程的interrupt方法，此時子線程還沒有處于sleep狀態。然后再第3次while循環的時候，在此進入sleep狀態，立馬拋出interruptedexception異常。
