一、線程的生命周期

線程狀態(tài)轉換圖：

1、新建狀態(tài)

用new關鍵字和Thread類或其子類建立一個線程對象后，該線程對象就處于新生狀態(tài)。處于新生狀態(tài)的線程有自己的內(nèi)存空間，通過調用start方法進入就緒狀態(tài)（runnable）。

注意：不能對已經(jīng)啟動的線程再次調用start()方法，否則會出現(xiàn)Javalang.IllegalThreadStateException異常。

2、就緒狀態(tài)

處于就緒狀態(tài)的線程已經(jīng)具備了運行條件，但還沒有分配到CPU，處于線程就緒隊列（盡管是采用隊列形式，事實上，把它稱為可運行池而不是可運行隊列。因為cpu的調度不一定是按照先進先出的順序來調度的），等待系統(tǒng)為其分配CPU。等待狀態(tài)并不是執(zhí)行狀態(tài)，當系統(tǒng)選定一個等待執(zhí)行的Thread對象后，它就會從等待執(zhí)行狀態(tài)進入執(zhí)行狀態(tài)，系統(tǒng)挑選的動作稱之為“cpu調度”。一旦獲得CPU，線程就進入運行狀態(tài)并自動調用自己的run方法。

提示：如果希望子線程調用start()方法后立即執(zhí)行，可以使用Thread.sleep()方式使主線程睡眠一伙兒，轉去執(zhí)行子線程。

3、運行狀態(tài)

處于運行狀態(tài)的線程最為復雜，它可以變?yōu)樽枞麪顟B(tài)、就緒狀態(tài)和死亡狀態(tài)。處于就緒狀態(tài)的線程，如果獲得了cpu的調度，就會從就緒狀態(tài)變?yōu)檫\行狀態(tài)，執(zhí)行run()方法中的任務。如果該線程失去了cpu資源，就會又從運行狀態(tài)變?yōu)榫途w狀態(tài)。重新等待系統(tǒng)分配資源。也可以對在運行狀態(tài)的線程調用yield()方法，它就會讓出cpu資源，再次變?yōu)榫途w狀態(tài)。

當發(fā)生如下情況是，線程會從運行狀態(tài)變?yōu)樽枞麪顟B(tài)：

①、線程調用sleep方法主動放棄所占用的系統(tǒng)資源

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

③、線程試圖獲得一個同步監(jiān)視器，但更改同步監(jiān)視器正被其他線程所持有

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

⑤、程序調用了線程的suspend方法將線程掛起。不過該方法容易導致死鎖，所以程序應該盡量避免使用該方法。

當線程的run()方法執(zhí)行完，或者被強制性地終止，例如出現(xiàn)異常，或者調用了stop()、desyory()方法等等，就會從運行狀態(tài)轉變?yōu)樗劳鰻顟B(tài)。

4、阻塞狀態(tài)

處于運行狀態(tài)的線程在某些情況下，如執(zhí)行了sleep（睡眠）方法，或等待I/O設備等資源，將讓出CPU并暫時停止自己的運行，進入阻塞狀態(tài)。
在阻塞狀態(tài)的線程不能進入就緒隊列。只有當引起阻塞的原因消除時，如睡眠時間已到，或等待的I/O設備空閑下來，線程便轉入就緒狀態(tài)，重新到就緒隊列中排隊等待，被系統(tǒng)選中后從原來停止的位置開始繼續(xù)運行。

5、死亡狀態(tài)

當線程的run()方法執(zhí)行完，或者被強制性地終止，就認為它死去。這個線程對象也許是活的，但是，它已經(jīng)不是一個單獨執(zhí)行的線程。線程一旦死亡，就不能復生。 如果在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。

二、線程狀態(tài)的控制

Java提供了一些便捷的方法用于會線程狀態(tài)的控制。

 .

可以看到很多方法，已經(jīng)標注為過時的，我們應該盡可能的避免使用它們，而應該重點關注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setDaemon()、setPriority()等間接控制方法。

1、線程睡眠——sleep

如果我們需要讓當前正在執(zhí)行的線程暫停一段時間，并進入阻塞狀態(tài)，則可以通過調用Thread的sleep方法，從上面可以看到sleep方法有兩種重載的形式，但是使用方法一樣。

比如，我們想要使主線程每休眠100毫秒，然后再打印出數(shù)字：

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

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

注意如下幾點問題

①、sleep是靜態(tài)方法，最好不要用Thread的實例對象調用它，因為它睡眠的始終是當前正在運行的線程，而不是調用它的線程對象，它只對正在運行狀態(tài)的線程對象有效?？聪旅娴睦樱?/p>

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多線程的核心，只有良好的調度，才能充分發(fā)揮系統(tǒng)的性能，提高程序的執(zhí)行效率。但是不管程序員怎么編寫調度，只能最大限度的影響線程執(zhí)行的次序，而不能做到精準控制。因為使用sleep方法之后，線程是進入阻塞狀態(tài)的，只有當睡眠的時間結束，才會重新進入到就緒狀態(tài)，而就緒狀態(tài)進入到運行狀態(tài)，是由系統(tǒng)控制的，我們不可能精準的去干涉它，所以如果調用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 + "次執(zhí)行！"); 
    try { 
     Thread.sleep(50); 
    } catch (InterruptedException e) { 
     e.printStackTrace(); 
    } 
   } 
  } 
 } 

看某一次的運行結果：

1. Thread-0線程0次執(zhí)行！ 
2. Thread-1線程0次執(zhí)行！ 
3. Thread-1線程1次執(zhí)行！ 
4. Thread-0線程1次執(zhí)行！ 
5. Thread-0線程2次執(zhí)行！ 
6. Thread-1線程2次執(zhí)行！ 

可以看到，線程0首先執(zhí)行，然后線程1執(zhí)行一次，又了執(zhí)行一次?？梢钥吹剿⒉皇前凑誷leep的順序執(zhí)行的。

2、線程讓步——yield

yield()方法和sleep()方法有點相似，它也是Thread類提供的一個靜態(tài)的方法，它也可以讓當前正在執(zhí)行的線程暫停，讓出cpu資源給其他的線程。但是和sleep()方法不同的是，它不會進入到阻塞狀態(tài)，而是進入到就緒狀態(tài)。yield()方法只是讓當前線程暫停一下，重新進入就緒的線程池中，讓系統(tǒng)的線程調度器重新調度器重新調度一次，完全可能出現(xiàn)這樣的情況：當某個線程調用yield()方法之后，線程調度器又將其調度出來重新進入到運行狀態(tài)執(zhí)行。

實際上，當某個線程調用了yield()方法暫停之后，優(yōu)先級與當前線程相同，或者優(yōu)先級比當前線程更高的就緒狀態(tài)的線程更有可能獲得執(zhí)行的機會，當然，只是有可能，因為我們不可能精確的干涉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);// 設置優(yōu)先級 
  } 
  @Override 
  public void run() { 
   for (int i = 0; i < 30; i++) { 
    System.out.println(this.getName() + "線程第" + i + "次執(zhí)行！"); 
   if (i % 5 == 0) 
     Thread.yield(); 
   } 
  } 
 } 

關于sleep()方法和yield()方的區(qū)別如下：

①、sleep方法暫停當前線程后，會進入阻塞狀態(tài)，只有當睡眠時間到了，才會轉入就緒狀態(tài)。而yield方法調用后 ，是直接進入就緒狀態(tài)，所以有可能剛進入就緒狀態(tài)，又被調度到運行狀態(tài)。

②、sleep方法聲明拋出了InterruptedException，所以調用sleep方法的時候要捕獲該異常，或者顯示聲明拋出該異常。而yield方法則沒有聲明拋出任務異常。

③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法來控制并發(fā)線程的執(zhí)行。

3、線程合并——join

線程的合并的含義就是將幾個并行線程的線程合并為一個單線程執(zhí)行，應用場景是當一個線程必須等待另一個線程執(zhí)行完畢才能執(zhí)行時，Thread類提供了join方法來完成這個功能，注意，它不是靜態(tài)方法。

從上面的方法的列表可以看到，它有3個重載的方法：

void join()   

    當前線程等該加入該線程后面，等待該線程終止。

void join(long millis)   

    當前線程等待該線程終止的時間最長為 millis 毫秒。 如果在millis時間內(nèi)，該線程沒有執(zhí)行完，那么當前線程進入就緒狀態(tài)，重新等待cpu調度  

void join(long millis,int nanos)   

    等待該線程終止的時間最長為 millis 毫秒 + nanos 納秒。如果在millis時間內(nèi)，該線程沒有執(zhí)行完，那么當前線程進入就緒狀態(tài)，重新等待cpu調度 

例子：

 public class Test1 { 
  public static void main(String[] args) throws InterruptedException { 
   MyThread thread=new MyThread(); 
   thread.start(); 
   thread.join(1);//將主線程加入到子線程后面，不過如果子線程在1毫秒時間內(nèi)沒執(zhí)行完，則主線程便不再等待它執(zhí)行完，進入就緒狀態(tài)，等待cpu調度 
   for(int i=0;i<30;i++){ 
    System.out.println(Thread.currentThread().getName() + "線程第" + i + "次執(zhí)行！"); 
   } 
  } 
 } 
 class MyThread extends Thread { 
  @Override 
 public void run() { 
   for (int i = 0; i < 1000; i++) { 
    System.out.println(this.getName() + "線程第" + i + "次執(zhí)行！"); 
   } 
  } 
 } 

在這個例子中，在主線程中調用thread.join(); 就是將主線程加入到thread子線程后面等待執(zhí)行。不過有時間限制，為1毫秒。

4、線程的優(yōu)先級

每個線程執(zhí)行時都有一個優(yōu)先級的屬性，優(yōu)先級高的線程可以獲得較多的執(zhí)行機會，而優(yōu)先級低的線程則獲得較少的執(zhí)行機會。與線程休眠類似，線程的優(yōu)先級仍然無法保障線程的執(zhí)行次序。只不過，優(yōu)先級高的線程獲取CPU資源的概率較大，優(yōu)先級低的也并非沒機會執(zhí)行。
每個線程默認的優(yōu)先級都與創(chuàng)建它的父線程具有相同的優(yōu)先級，在默認情況下，main線程具有普通優(yōu)先級。

Thread類提供了setPriority(int newPriority)和getPriority()方法來設置和返回一個指定線程的優(yōu)先級，其中setPriority方法的參數(shù)是一個整數(shù)，范圍是1~•0之間，也可以使用Thread類提供的三個靜態(tài)常量：

• 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);//設置線程的優(yōu)先級 
  } 
  @Override 
  public void run() { 
   for (int i = 0; i < 100; i++) { 
    System.out.println(this.getName() + "線程第" + i + "次執(zhí)行！"); 
   } 
  } 
 } 

從結果可以看到 ，一般情況下，高級線程更顯執(zhí)行完畢。

注意一點：雖然Java提供了10個優(yōu)先級別，但這些優(yōu)先級別需要操作系統(tǒng)的支持。不同的操作系統(tǒng)的優(yōu)先級并不相同，而且也不能很好的和Java的10個優(yōu)先級別對應。所以我們應該使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三個靜態(tài)常量來設定優(yōu)先級，這樣才能保證程序最好的可移植性。

5、守護線程

守護線程與普通線程寫法上基本么啥區(qū)別，調用線程對象的方法setDaemon(true)，則可以將其設置為守護線程。 

守護線程使用的情況較少，但并非無用，舉例來說，JVM的垃圾回收、內(nèi)存管理等線程都是守護線程。還有就是在做數(shù)據(jù)庫應用時候，使用的數(shù)據(jù)庫連接池，連接池本身也包含著很多后臺線程，監(jiān)控連接個數(shù)、超時時間、狀態(tài)等等。 

setDaemon方法的詳細說明：

public final void setDaemon(boolean on)將該線程標記為守護線程或用戶線程。當正在運行的線程都是守護線程時，Java 虛擬機退出。  

該方法必須在啟動線程前調用。 該方法首先調用該線程的 checkAccess 方法，且不帶任何參數(shù)。這可能拋出 SecurityException（在當前線程中）。  

  參數(shù)：

    on - 如果為 true，則將該線程標記為守護線程。       

  拋出：   

    IllegalThreadStateException - 如果該線程處于活動狀態(tài)。     

    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 + "次執(zhí)行！"); 
       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 + "次執(zhí)行！"); 
       try { 
         Thread.sleep(7); 
       } catch (InterruptedException e) { 
         e.printStackTrace(); 
       } 
     } 
   } 
 } 

執(zhí)行結果：

1. 后臺線程第0次執(zhí)行！ 
2. 線程1第0次執(zhí)行！ 
3. 線程1第1次執(zhí)行！ 
4. 后臺線程第1次執(zhí)行！ 
5. 后臺線程第2次執(zhí)行！ 
6. 線程1第2次執(zhí)行！ 
7. 線程1第3次執(zhí)行！ 
8. 后臺線程第3次執(zhí)行！ 
9. 線程1第4次執(zhí)行！ 
10. 后臺線程第4次執(zhí)行！ 
11. 后臺線程第5次執(zhí)行！ 
12. 后臺線程第6次執(zhí)行！ 
13. 后臺線程第7次執(zhí)行！

從上面的執(zhí)行結果可以看出：前臺線程是保證執(zhí)行完畢的，后臺線程還沒有執(zhí)行完畢就退出了。 

實際上：JRE判斷程序是否執(zhí)行結束的標準是所有的前臺執(zhí)線程行完畢了，而不管后臺線程的狀態(tài)，因此，在使用后臺縣城時候一定要注意這個問題。

守護線程的用途：

守護線程通常用于執(zhí)行一些后臺作業(yè)，例如在你的應用程序運行時播放背景音樂，在文字編輯器里做自動語法檢查、自動保存等功能。Java的垃圾回收也是一個守護線程。守護線的好處就是你不需要關心它的結束問題。例如你在你的應用程序運行的時候希望播放背景音樂，如果將這個播放背景音樂的線程設定為非守護線程，那么在用戶請求退出的時候，不僅要退出主線程，還要通知播放背景音樂的線程退出；如果設定為守護線程則不需要了。

6、如何結束一個線程

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

1、正常執(zhí)行完run方法，然后結束掉

2、控制循環(huán)條件和判斷條件的標識符來結束掉線程

比如說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方法能夠執(zhí)行完畢即可。而不是while(true)的無線循環(huán)。

3、使用interrupt結束一個線程。

誠然，使用第2中方法的標識符來結束一個線程，是一個不錯的方法，但是如果，該線程是處于sleep、wait、join的狀態(tài)的時候，while循環(huán)就不會執(zhí)行，那么我們的標識符就無用武之地了，當然也不能再通過它來結束處于這3種狀態(tài)的線程了。

可以使用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的異常。

在什么時候會產(chǎn)生這樣一個異常呢？

每個Thread都有一個中斷狀狀態(tài)，默認為false?？梢酝ㄟ^Thread對象的isInterrupted()方法來判斷該線程的中斷狀態(tài)?？梢酝ㄟ^Thread對象的interrupt()方法將中斷狀態(tài)設置為true。

當一個線程處于sleep、wait、join這三種狀態(tài)之一的時候，如果此時他的中斷狀態(tài)為true，那么它就會拋出一個InterruptedException的異常，并將中斷狀態(tài)重新設置為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. 1 
2. false 
3. 我馬上去sleep了 
4. 2 
5. true 
6. 我馬上去sleep了 
7. 異常捕獲了false 

可以看到，首先執(zhí)行第一次while循環(huán)，在第一次循環(huán)中，睡眠2秒，然后將中斷狀態(tài)設置為true。當進入到第二次循環(huán)的時候，中斷狀態(tài)就是第一次設置的true，當它再次進入sleep的時候，馬上就拋出了InterruptedException異常，然后被我們捕獲了。然后中斷狀態(tài)又被重新自動設置為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++; 
  } 
  } 
 } 

多測試幾次，會發(fā)現(xiàn)一般有兩種執(zhí)行結果：

 0 
1  
 2 

4. 中斷異常被捕獲了

或者

 0  
 1 
2 
3 

5. 中斷異常被捕獲了 

這兩種結果恰恰說明了  只要一個線程的中斷狀態(tài)一旦為true，只要它進入sleep等狀態(tài)，或者處于sleep狀態(tài)，立馬回拋出InterruptedException異常。

第一種情況，是當主線程從3秒睡眠狀態(tài)醒來之后，調用了子線程的interrupt方法，此時子線程正處于sleep狀態(tài)，立馬拋出InterruptedException異常。

第一種情況，是當主線程從3秒睡眠狀態(tài)醒來之后，調用了子線程的interrupt方法，此時子線程還沒有處于sleep狀態(tài)。然后再第3次while循環(huán)的時候，在此進入sleep狀態(tài)，立馬拋出InterruptedException異常。

最新評論