0 前言
當線程被創建並啟動以后，它既不是一啟動就進入了執行狀態，也不是一直處於執行狀態。在線程的生命周期中，它要經過 新建（New）、就緒（Runnable）、運行（Running）、阻塞（Blocked）和死亡（Dead）5種狀態。尤其是當線程啟動以后，它不可能一直"霸占"着CPU獨自運行，所以CPU需要在多條線程之間切換，於是 線程狀態也會多次在運行、阻塞之間切換。
線程狀態轉換關系
1 新建（New）狀態
當程序使用new關鍵字創建了一個線程之后，該線程就處於 新建狀態，此時的線程情況如下：
- 此時JVM為其分配內存，並初始化其成員變量的值；
- 此時線程對象沒有表現出任何線程的動態特征，程序也不會執行線程的線程執行體；
2 就緒（Runnable）狀態
當線程對象調用了start()方法之后，該線程處於 就緒狀態。此時的線程情況如下：
- 此時JVM會為其 創建方法調用棧和程序計數器；
- 該狀態的線程一直處於 線程就緒隊列（盡管是采用隊列形式，事實上，把它稱為可運行池而不是可運行隊列。因為CPU的調度不一定是按照先進先出的順序來調度的），線程並沒有開始運行；
- 此時線程 等待系統為其分配CPU時間片，並不是說執行了start()方法就立即執行；
調用start()方法與run()方法，對比如下：
- 調用start()方法來啟動線程，系統會把該run()方法當成線程執行體來處理。但如果直接調用線程對象的run()方法，則run()方法立即就會被執行，而且在run()方法返回之前其他線程無法並發執行。也就是說，系統把線程對象當成一個普通對象，而run()方法也是一個普通方法，而不是線程執行體；
- 需要指出的是，調用了線程的run()方法之后，該線程已經不再處於新建狀態，不要再次調用線程對象的start()方法。只能對處於新建狀態的線程調用start()方法，否則將引發IllegaIThreadStateExccption異常；
如何讓子線程調用start()方法之后立即執行而非"等待執行"：
程序可以使用Thread.sleep(1) 來讓當前運行的線程（主線程）睡眠1毫秒，1毫秒就夠了，因為在這1毫秒內CPU不會空閑，它會去執行另一個處於就緒狀態的線程，這樣就可以讓子線程立即開始執行；
3 運行（Running）狀態
當CPU開始調度處於 就緒狀態 的線程時，此時線程獲得了CPU時間片才得以真正開始執行run()方法的線程執行體，則該線程處於 運行狀態。
- 如果計算機只有一個CPU，那么在任何時刻只有一個線程處於運行狀態；
- 如果在一個多處理器的機器上，將會有多個線程並行執行，處於運行狀態；
- 當線程數大於處理器數時，依然會存在多個線程在同一個CPU上輪換的現象；
處於運行狀態的線程最為復雜，它 不可能一直處於運行狀態（除非它的線程執行體足夠短，瞬間就執行結束了），線程在運行過程中需要被中斷，目的是使其他線程獲得執行的機會，線程調度的細節取決於底層平台所采用的策略。線程狀態可能會變為 阻塞狀態、就緒狀態和死亡狀態。比如：
- 對於采用 搶占式策略 的系統而言，系統會給每個可執行的線程分配一個時間片來處理任務；當該時間片用完后，系統就會剝奪該線程所占用的資源，讓其他線程獲得執行的機會。線程就會又 從運行狀態變為就緒狀態，重新等待系統分配資源；
- 對於采用 協作式策略的系統而言，只有當一個線程調用了它的yield()方法后才會放棄所占用的資源—也就是必須由該線程主動放棄所占用的資源，線程就會又 從運行狀態變為就緒狀態。
4 阻塞（Blocked）狀態
處於運行狀態的線程在某些情況下，讓出CPU並暫時停止自己的運行，進入 阻塞狀態。
當發生如下情況時，線程將會進入阻塞狀態：
- 線程調用sleep()方法，主動放棄所占用的處理器資源，暫時進入中斷狀態（不會釋放持有的對象鎖），時間到后等待系統分配CPU繼續執行；
- 線程調用一個阻塞式IO方法，在該方法返回之前，該線程被阻塞；
- 線程試圖獲得一個同步監視器，但該同步監視器正被其他線程所持有;
- 程序調用了線程的suspend方法將線程掛起；
- 線程調用wait，等待notify/notifyAll喚醒時(會釋放持有的對象鎖)；
阻塞狀態分類：
- 等待阻塞：運行狀態中的 線程執行wait()方法，使本線程進入到等待阻塞狀態；
- 同步阻塞：線程在 獲取synchronized同步鎖失敗（因為鎖被其它線程占用），它會進入到同步阻塞狀態；
- 其他阻塞：通過調用線程的 sleep()或join()或發出I/O請求 時，線程會進入到阻塞狀態。當 sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢 時，線程重新轉入就緒狀態；
在阻塞狀態的線程只能進入就緒狀態，無法直接進入運行狀態。而就緒和運行狀態之間的轉換通常不受程序控制，而是由系統線程調度所決定。當處於就緒狀態的線程獲得處理器資源時，該線程進入運行狀態；當處於運行狀態的線程失去處理器資源時，該線程進入就緒狀態。
但有一個方法例外，調用yield()方法可以讓運行狀態的線程轉入就緒狀態。
4.1 等待（WAITING）狀態
線程處於 無限制等待狀態，等待一個特殊的事件來重新喚醒，如：
- 通過wait()方法進行等待的線程等待一個notify()或者notifyAll()方法；
- 通過join()方法進行等待的線程等待目標線程運行結束而喚醒；
以上兩種一旦通過相關事件喚醒線程，線程就進入了 就緒（RUNNABLE）狀態 繼續運行。
4.2 時限等待（TIMED_WAITING）狀態
線程進入了一個 時限等待狀態，如：
sleep(3000)，等待3秒后線程重新進行 就緒（RUNNABLE）狀態 繼續運行。
5 死亡（Dead）狀態
線程會以如下3種方式結束，結束后就處於 死亡狀態：
- run()或call()方法執行完成，線程正常結束；
- 線程拋出一個未捕獲的Exception或Error；
- 直接調用該線程stop()方法來結束該線程—該方法容易導致死鎖，通常不推薦使用；
處於死亡狀態的線程對象也許是活的，但是，它已經不是一個單獨執行的線程。線程一旦死亡，就不能復生。 如果在一個死去的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。
所以，需要注意的是：
一旦線程通過start()方法啟動后就再也不能回到新建（NEW）狀態，線程終止后也不能再回到就緒（RUNNABLE）狀態。
5.1 終止（TERMINATED）狀態
線程執行完畢后，進入終止（TERMINATED）狀態。
6 線程相關方法
public class Thread{ // 線程的啟動 public void start(); // 線程體 public void run(); // 已廢棄 public void stop(); // 已廢棄 public void resume(); // 已廢棄 public void suspend(); // 在指定的毫秒數內讓當前正在執行的線程休眠 public static void sleep(long millis); // 同上，增加了納秒參數 public static void sleep(long millis, int nanos); // 測試線程是否處於活動狀態 public boolean isAlive(); // 中斷線程 public void interrupt(); // 測試線程是否已經中斷 public boolean isInterrupted(); // 測試當前線程是否已經中斷 public static boolean interrupted(); // 等待該線程終止 public void join() throws InterruptedException; // 等待該線程終止的時間最長為 millis 毫秒 public void join(long millis) throws InterruptedException; // 等待該線程終止的時間最長為 millis 毫秒 + nanos 納秒 public void join(long millis, int nanos) throws InterruptedException; }
線程方法狀態轉換
6.1 線程就緒、運行和死亡狀態轉換
- 就緒狀態轉換為運行狀態：此線程得到CPU資源；
- 運行狀態轉換為就緒狀態：此線程主動調用yield()方法或在運行過程中失去CPU資源。
- 運行狀態轉換為死亡狀態：此線程執行執行完畢或者發生了異常；
注意：
當調用線程中的yield()方法時，線程從運行狀態轉換為就緒狀態，但接下來CPU調度就緒狀態中的那個線程具有一定的隨機性，因此，可能會出現A線程調用了yield()方法后，接下來CPU仍然調度了A線程的情況。
6.2 run & start
通過調用start啟動線程，線程執行時會執行run方法中的代碼。
- start()：線程的啟動；
- run()：線程的執行體；
6.3 sleep & yield
sleep()：通過sleep(millis)使線程進入休眠一段時間，該方法在指定的時間內無法被喚醒，同時也不會釋放對象鎖；
比如，我們想要使主線程每休眠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(); // 這里sleep的就是main線程，而非myThread線程 myThread.sleep(1000); 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(); } } } }
看某一次的運行結果：可以發現，線程0首先執行，然后線程1執行一次，又了執行一次。發現並不是按照sleep的順序執行的。
Thread-0線程0次執行！
Thread-1線程0次執行！
Thread-1線程1次執行！
Thread-0線程1次執行！
Thread-0線程2次執行！
Thread-1線程2次執行！
yield()：與sleep類似，也是Thread類提供的一個靜態的方法，它也可以讓當前正在執行的線程暫停，讓出CPU資源給其他的線程。但是和sleep()方法不同的是，它不會進入到阻塞狀態，而是進入到就緒狀態。yield()方法只是讓當前線程暫停一下，重新進入就緒線程池中，讓系統的線程調度器重新調度器重新調度一次，完全可能出現這樣的情況：當某個線程調用yield()方法之后，線程調度器又將其調度出來重新進入到運行狀態執行。
實際上，當某個線程調用了yield()方法暫停之后，優先級與當前線程相同，或者優先級比當前線程更高的就緒狀態的線程更有可能獲得執行的機會，當然，只是有可能，因為我們不可能精確的干涉cpu調度線程。
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方法來控制並發線程的執行；
6.4 join
線程的合並的含義就是 將幾個並行線程的線程合並為一個單線程執行，應用場景是 當一個線程必須等待另一個線程執行完畢才能執行時，Thread類提供了join方法來完成這個功能，注意，它不是靜態方法。
join有3個重載的方法：
void join()
當前線程等該加入該線程后面，等待該線程終止。
void join(long millis)
當前線程等待該線程終止的時間最長為 millis 毫秒。 如果在millis時間內，該線程沒有執行完，那么當前線程進入就緒狀態，重新等待cpu調度
void join(long millis,int nanos)
等待該線程終止的時間最長為 millis 毫秒 + nanos 納秒。如果在millis時間內，該線程沒有執行完，那么當前線程進入就緒狀態，重新等待cpu調度
例子代碼，如下：
/** * 在主線程中調用thread.join(); 就是將主線程加入到thread子線程后面等待執行。不過有時間限制，為1毫秒。 */ public class Test1 { public static void main(String[] args) throws InterruptedException { MyThread t=new MyThread(); t.start(); t.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 + "次執行！"); } } }
在JDK中join方法的源碼，如下：
public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { throw new IllegalArgumentException("timeout value is negative"); } if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }
join方法實現是通過調用wait方法實現。當main線程調用t.join時候，main線程會獲得線程對象t的鎖（wait 意味着拿到該對象的鎖)，調用該對象的wait(等待時間)，直到該對象喚醒main線程，比如退出后。這就意味着main 線程調用t.join時，必須能夠拿到線程t對象的鎖。
6.5 suspend & resume (已過時)
suspend-線程進入阻塞狀態，但不會釋放鎖。此方法已不推薦使用，因為同步時不會釋放鎖，會造成死鎖的問題。
resume-使線程重新進入可執行狀態。
為什么 Thread.suspend 和 Thread.resume 被廢棄了？
Thread.suspend 天生容易引起死鎖。如果目標線程掛起時在保護系統關鍵資源的監視器上持有鎖，那么其他線程在目標線程恢復之前都無法訪問這個資源。如果要恢復目標線程的線程在調用 resume 之前試圖鎖定這個監視器，死鎖就發生了。這種死鎖一般自身表現為“凍結（ frozen ）”進程。
其他相關資料：
6.6 stop（已過時）
不推薦使用，且以后可能去除，因為它不安全。為什么 Thread.stop 被廢棄了？
因為其天生是不安全的。停止一個線程會導致其解鎖其上被鎖定的所有監視器（監視器以在棧頂產生ThreadDeath異常的方式被解鎖）。如果之前被這些監視器保護的任何對象處於不一致狀態，其它線程看到的這些對象就會處於不一致狀態。這種對象被稱為受損的 （damaged）。當線程在受損的對象上進行操作時，會導致任意行為。這種行為可能微妙且難以檢測，也可能會比較明顯。
不像其他未受檢的（unchecked）異常， ThreadDeath 悄無聲息的殺死及其他線程。因此，用戶得不到程序可能會崩潰的警告。崩潰會在真正破壞發生后的任意時刻顯現，甚至在數小時或數天之后。
其他相關資料：
6.7 wait & notify/notifyAll
wait & notify/notifyAll這三個都是Object類的方法。使用 wait ，notify 和 notifyAll 前提是先獲得調用對象的鎖。
- 調用 wait 方法后，釋放持有的對象鎖，線程狀態有 Running 變為 Waiting，並將當前線程放置到對象的 等待隊列；
- 調用notify 或者 notifyAll 方法后，等待線程依舊不會從 wait 返回，需要調用 notify 的線程釋放鎖之后，等待線程才有機會從 wait 返回；
- notify 方法：將等待隊列的一個等待線程從等待隊列種移到同步隊列中 ，而 notifyAll 方法：將等待隊列種所有的線程全部移到同步隊列，被移動的線程狀態由 Waiting 變為 Blocked。
前面一直提到兩個概念，等待隊列（等待池），同步隊列（鎖池），這兩者是不一樣的。具體如下：
同步隊列（鎖池）：假設線程A已經擁有了某個對象（注意:不是類）的鎖，而其它的線程想要調用這個對象的某個synchronized方法(或者synchronized塊)，由於這些線程在進入對象的synchronized方法之前必須先獲得該對象的鎖的擁有權，但是該對象的鎖目前正被線程A擁有，所以這些線程就進入了該對象的同步隊列（鎖池）中，這些線程狀態為Blocked。
等待隊列（等待池）：假設一個線程A調用了某個對象的wait()方法，線程A就會釋放該對象的鎖（因為wait()方法必須出現在synchronized中，這樣自然在執行wait()方法之前線程A就已經擁有了該對象的鎖），同時 線程A就進入到了該對象的等待隊列（等待池）中，此時線程A狀態為Waiting。如果另外的一個線程調用了相同對象的notifyAll()方法，那么 處於該對象的等待池中的線程就會全部進入該對象的同步隊列（鎖池）中，准備爭奪鎖的擁有權。如果另外的一個線程調用了相同對象的notify()方法，那么 僅僅有一個處於該對象的等待池中的線程（隨機）會進入該對象的同步隊列（鎖池）。
被notify或notifyAll喚起的線程是有規律的，具體如下：
- 如果是通過notify來喚起的線程，那 先進入wait的線程會先被喚起來；
- 如果是通過nootifyAll喚起的線程，默認情況是 最后進入的會先被喚起來，即LIFO的策略；
6.8 線程優先級
每個線程執行時都有一個優先級的屬性，優先級高的線程可以獲得較多的執行機會，而優先級低的線程則獲得較少的執行機會。與線程休眠類似，線程的優先級仍然無法保障線程的執行次序。只不過，優先級高的線程獲取CPU資源的概率較大，優先級低的也並非沒機會執行。
每個線程默認的優先級都與創建它的父線程具有相同的優先級，在默認情況下，main線程具有普通優先級；
Thread類提供了setPriority(int newPriority)和getPriority()方法來設置和返回一個指定線程的優先級，其中setPriority方法的參數是一個整數，范圍是1~10之間，也可以使用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三個靜態常量來設定優先級，這樣才能保證程序最好的可移植性。
6.9 守護線程
守護線程與普通線程寫法上基本沒啥區別，調用線程對象的方法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判斷程序是否執行結束的標准是所有的前台執線程行完畢了，而不管后台線程的狀態，因此，在使用后台線程時候一定要注意這個問題。
6.10 如何結束一個線程
Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit 這些終止線程運行的方法已經被廢棄了，使用它們是極端不安全的！想要安全有效的結束一個線程，可以使用下面的方法。
- 正常執行完run方法，然后結束掉；
- 控制循環條件和判斷條件的標識符來結束掉線程；
比如run方法這樣寫：只要保證在一定的情況下，run方法能夠執行完畢即可。而不是while(true)的無限循環。
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); } } }
誠然，使用上面方法的標識符來結束一個線程，是一個不錯的方法，但其也有弊端，如果 該線程是處於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異常。