線程的生命週期以及控制線程

1、線程的生命週期

線程狀態轉換圖：

一、新建狀態

用newkeyword和Thread類或其子類創建一個線程對象後，該線程對象就處於新生狀態。處於新生狀態的線程有本身的內存空間，經過調用start方法進入就緒狀態（runnable）。

注意：不能對已經啓動的線程再次調用start()方法，不然會出現java.lang.IllegalThreadStateException異常。

2、就緒狀態

處於就緒狀態的線程已經具有了執行條件，但尚未分配到CPU。處於線程就緒隊列（雖然是採用隊列形式。其實，把它稱爲可執行池而不是可執行隊列。因爲cpu的調度不必定是依照先進先出的順序來調度的），等待系統爲其分配CPU。等待狀態並不是執行狀態。當系統選定一個等待執行的Thread對象後。它就會從等待執行狀態進入執行狀態，系統挑選的動做稱之爲「cpu調度」。

一旦得到CPU。線程就進入執行狀態並本身主動調用本身的run方法。

提示：假設但願子線程調用start()方法後立刻運行。可以使用Thread.sleep()方式使主線程睡眠一夥兒，轉去運行子線程。

三、執行狀態

處於執行狀態的線程最爲複雜。它可以變爲堵塞狀態、就緒狀態和死亡狀態。

處於就緒狀態的線程。假設得到了cpu的調度，就會從就緒狀態變爲執行狀態，執行run()方法中的任務。假設該線程失去了cpu資源，就會又從執行狀態變爲就緒狀態。又一次等待系統分配資源。也可以對在執行狀態的線程調用yield()方法，它就會讓出cpu資源。再次變爲就緒狀態。

當發生例如如下狀況是。線程會從執行狀態變爲堵塞狀態：

①、線程調用sleep方法主動放棄所佔用的系統資源

②、線程調用一個堵塞式IO方法，在該方法返回以前，該線程被堵塞

③、線程試圖得到一個同步監視器，但更改同步監視器正被其它線程所持有

④、線程在等待某個通知（notify）

⑤、程序調用了線程的suspend方法將線程掛起。只是該方法easy致使死鎖。因此程序應該儘可能避免使用該方法。

當線程的run()方法執行完。或者被強制性地終止，好比出現異常，或者調用了stop()、desyory()方法等等。就會從執行狀態轉變爲死亡狀態。

四、堵塞狀態

處於執行狀態的線程在某些狀況下，如執行了sleep（睡眠）方法。或等待I/O設備等資源，將讓出CPU並臨時中止本身的執行，進入堵塞狀態。

 

在堵塞狀態的線程不能進入就緒隊列。

僅僅有當引發堵塞的緣由消除時，如睡眠時間已到，或等待的I/O設備空暇下來。線程便轉入就緒狀態。又一次到就緒隊列中排隊等待。被系統選中後從原來中止的位置開始繼續執行。有三種方法可以暫停Threads執行：

五、死亡狀態

當線程的run()方法運行完。或者被強制性地終止。就以爲它死去。這個線程對象或許是活的，但是。它已經不是一個單獨運行的線程。

線程一旦死亡。就不能復生。 假設在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。

2、線程狀態的控制

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()等間接控制方法。

一、線程睡眠——sleep

假設咱們需要讓當前正在運行的線程暫停一段時間。並進入堵塞狀態，則可以經過調用Thread的sleep方法。從上面可以看到sleep方法有兩種重載的形式，但是用法同樣。

比方，咱們想要使主線程每休眠100毫秒。而後再打印出數字：

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

可以明顯看到打印的數字在時間上有些許的間隔。

注意例如如下幾點問題

①、sleep是靜態方法。最好不要用Thread的實例對象調用它，因爲它睡眠的始終是當前正在執行的線程，而不是調用它的線程對象。它僅僅對正在執行狀態的線程對象有效。看如下的樣例：

 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秒。

 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();
             }
         }
     }
 }

看某一次的執行結果：

 Thread-0線程0次運行！
 Thread-1線程0次運行！
 Thread-1線程1次運行！
 Thread-0線程1次運行！
 Thread-0線程2次運行。
 Thread-1線程2次運行！

可以看到。線程0首先運行，而後線程1運行一次。又了運行一次。

可以看到它並不是依照sleep的順序運行的。

二、線程讓步——yield

yield()方法和sleep()方法有點類似，它也是Thread類提供的一個靜態的方法，它也可以讓當前正在運行的線程暫停，讓出cpu資源給其它的線程。但是和sleep()方法不一樣的是，它不會進入到堵塞狀態，而是進入到就緒狀態。yield()方法僅僅是讓當前線程暫停一下，又一次進入就緒的線程池中。讓系統的線程調度器又一次調度器又一次調度一次，全然可能出現這種狀況：當某個線程調用yield()方法以後。線程調度器又將其調度出來又一次進入到運行狀態運行。

實際上。當某個線程調用了yield()方法暫停以後，優先級與當前線程一樣，或者優先級比當前線程更高的就緒狀態的線程更有可能得到運行的機會。固然，僅僅是有可能，因爲咱們不可能精確的干涉cpu調度線程。

yield的使用方法：

 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方法來控制併發線程的運行。

三、線程合併——join

線程的合併的含義就是將幾個並行線程的線程合併爲一個單線程運行。應用場景是當一個線程必須等待還有一個線程運行完畢才幹運行時，Thread類提供了join方法來完畢這個功能，注意，它不是靜態方法。

從上面的方法的列表可以看到，它有3個重載的方法：
void join()    
    當前線程等該增長該線程後面，等待該線程終止。    
void join(long millis)    
    當前線程等待該線程終止的時間最長爲 millis 毫秒。

假設在millis時間內，該線程沒有運行完，那麼當前線程進入就緒狀態，又一次等待cpu調度   
void join(long millis,int nanos)    
    等待該線程終止的時間最長爲 millis 毫秒 + nanos 納秒。假設在millis時間內。該線程沒有運行完，那麼當前線程進入就緒狀態。又一次等待cpu調度  

樣例：

 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 {
     @Override
     public void run() {
         for (int i = 0; i < 1000; i++) {
             System.out.println(this.getName() + "線程第" + i + "次運行！");
         }
     }
 }

在這個樣例中，在主線程中調用thread.join(); 就是將主線程增長到thread子線程後面等待運行。只是有時間限制，爲1毫秒。

四、線程的優先級

每個線程運行時都有一個優先級的屬性，優先級高的線程可以得到較多的運行機會。而優先級低的線程則得到較少的運行機會。與線程休眠相似。線程的優先級仍然沒法保障線程的運行次序。僅僅只是，優先級高的線程獲取CPU資源的機率較大，優先級低的也並非沒機會運行。

每個線程默認的優先級都與建立它的父線程具備一樣的優先級，在默認狀況下。main線程具備普通優先級。

Thread類提供了setPriority(int newPriority)和getPriority()方法來設置和返回一個指定線程的優先級，當中setPriority方法的參數是一個整數，範圍是1~·0之間。也可以使用Thread類提供的三個靜態常量：

MAX_PRIORITY   =10

MIN_PRIORITY   =1

NORM_PRIORITY   =5

樣例：

 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三個靜態常量來設定優先級，這樣才幹保證程序最好的可移植性。

五、守護線程

守護線程與普通線程寫法上基本麼啥差異，調用線程對象的方法setDaemon(true)，則可以將其設置爲守護線程。

 

守護線程使用的狀況較少。但並非無用，舉例來講，JVM的垃圾回收、內存管理等線程都是守護線程。還有就是在作數據庫應用時候。使用的數據庫鏈接池。鏈接池自己也包括着很是多後臺線程。監控鏈接個數、超時時間、狀態等等。

 

setDaemon方法的具體說明：
public final void setDaemon(boolean on)將該線程標記爲守護線程或用戶線程。當正在執行的線程都是守護線程時，Java 虛擬機退出。    
該方法必須在啓動線程前調用。 該方法首先調用該線程的 checkAccess 方法，且不帶不論什麼參數。這可能拋出 SecurityException（在當前線程中）。   
  參數： 
    on - 假設爲 true，則將該線程標記爲守護線程。

    
  拋出：    
    IllegalThreadStateException - 假設該線程處於活動狀態。    
    SecurityException - 假設當前線程沒法改動該線程。

 /**
 * 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();
                         }
                 }
         }
 }

運行結果：

 後臺線程第0次運行！
 線程1第0次運行！
 線程1第1次運行！
 後臺線程第1次運行！
 後臺線程第2次運行。
 線程1第2次運行。
 線程1第3次運行。
 後臺線程第3次運行！
 線程1第4次運行！
 後臺線程第4次運行！
 後臺線程第5次運行。
 後臺線程第6次運行！
 後臺線程第7次運行！

從上面的運行結果可以看出：前臺線程是保證運行完成的，後臺線程尚未運行完成就退出了。

 

實際上：JRE推斷程序是否運行結束的標準是所有的前臺執線程行完成了，而不管後臺線程的狀態。所以，在使用後臺縣城時候必定要注意這個問題。

守護線程的用途：

守護線程通常用於執行一些後臺做業，好比在你的應用程序執行時播放背景音樂。在文字編輯器裏作本身主動語法檢查、本身主動保存等功能。

Java的垃圾回收也是一個守護線程。

守護線

的優勢就是你不需要關心它的結束問題。好比你在你的應用程序執行的時候但願播放背景音樂。假設將這個播放背景音樂的線程設定爲非守護線程，那麼在用戶請求退出的時候。

不只要退出主線程，還要通知播放背景音樂的線程退出；假設設定爲守護線程則不需要了。

六、怎樣結束一個線程

Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit這些終止線程執行的方法已經被廢棄了。使用它們是極端不安全的！想要安全有效的結束一個線程，可以使用如下的方法。

一、正常運行完run方法，而後結束掉

二、控制循環條件和推斷條件的標識符來結束掉線程

比方說run方法這樣寫：

 class MyThread extends Thread {
     int i=0;
     @Override
     public void run() {
         while (true) {
             if(i==10)
                 break;
             i++;
             System.out.println(i);

         }
     }
 }

或者

 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);
         }
     }
 }

或者

 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)的無線循環。

三、使用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。

看如下的簡單的樣例：

 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
 false
 我當即去sleep了
 2
 true
 我當即去sleep了
 異常捕獲了false

可以看到。首先運行第一次while循環，在第一次循環中，睡眠2秒。而後將中斷狀態設置爲true。當進入到第二次循環的時候，中斷狀態就是第一次設置的true，當它再次進入sleep的時候，當即就拋出了InterruptedException異常，而後被咱們捕獲了。而後中斷狀態又被又一次本身主動設置爲false了（從最後一條輸出可以看出來）。

因此，咱們可以使用interrupt方法結束一個線程。

詳細使用例如如下：

 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
 中斷異常被捕獲了

或者

 0
 1
 2
 3
 中斷異常被捕獲了

這兩種結果偏偏說明了  僅僅要一個線程的中斷狀態一旦爲true，僅僅要它進入sleep等狀態。或者處於sleep狀態，馬上回拋出InterruptedException異常。

第一種狀況，是當主線程從3秒睡眠狀態醒來以後。調用了子線程的interrupt方法。此時子線程正處於sleep狀態，馬上拋出InterruptedException異常。

第一種狀況。是當主線程從3秒睡眠狀態醒來以後。調用了子線程的interrupt方法，此時子線程尚未處於sleep狀態。而後再第3次while循環的時候，在此進入sleep狀態。馬上拋出InterruptedException異常。