一，介紹

這篇文章主要記錄使用 interrupt() 方法中斷執行緒，以及如何對InterruptedException進行處理。感覺對InterruptedException異常進行處理是一件謹慎且有技巧的活兒。

由於使用stop()方法停止執行緒非常的暴力，人家執行緒執行的好好的，突然就把人家殺死了，執行緒佔用的鎖被強制釋放，極易導致資料的不一致性。可參考這篇文章對stop()方法的介紹。

因此，提出了一種溫和的方式：請求另外一個執行緒不要再執行了，這就是中斷方式。

二，中斷及如何響應中斷？

如何優雅地響應中斷真的是太高深了，看到這篇文章：Java 理論與實踐: 處理 InterruptedException

假設某個執行緒要不停地處理某件事情(比如 i 一直自增)，但是還有個要求：在處理事情前，先要檢查下這個執行緒是否被中斷，如果已經被中斷，處理就應該結束。

下面是一些例子，這些例子摘自書本：

 1 public class Run {
 2 
 3     public static void main(String[] args) {
 4         try {
 5             MyThread thread = new MyThread();
 6             thread.start();
 
 7             Thread.sleep(20);//modify 2000 to 20
 8             thread.interrupt();//請求中斷MyThread執行緒
 9         } catch (InterruptedException e) {
10             System.out.println("main catch");
11             e.printStackTrace();
12         }
13         System.out.println("end!");
14     }
15 }

main執行緒睡眠20ms後，執行第8行中斷MyThread執行緒。

 1 public class MyThread extends Thread {
 2     @Override
 3     public void run() {
 4         super.run();
 5         for (int i = 0; i < 500000; i++) {
 6             if (this.interrupted()) {
 7                 System.out.println("should be stopped and exit");
 8                 break;
 9             }
10             System.out.println("i=" + (i + 1));
11         }
12         System.out.println("this line is also executed. thread does not stopped");//儘管執行緒被中斷,但並沒有結束執行。這行程式碼還是會被執行
13     }
14 }

當MyThread獲得CPU執行時，第6行的 if 測試中，檢測到中斷標識被設定。即MyThread執行緒檢測到了main執行緒想要中斷它的 請求。

大多數情況下，MyThread檢測到了中斷請求，對該中斷的響應是：退出執行（或者說是結束執行）。

但是，上面第5至8行for迴圈，是執行break語句跳出for迴圈。但是，執行緒並沒有結束，它只是跳出了for迴圈而已，它還會繼續執行第12行的程式碼....

因此，我們的問題是，當收到了中斷請求後，如何結束該執行緒呢？

一種可行的方法是使用 return 語句 而不是 break語句。。。。。哈哈。。。

當然，一種更優雅的方式則是：丟擲InterruptedException異常。

看下面MyThread類的程式碼：

 1 public class MyThread extends Thread {
 2     @Override
 3     public void run() {
 4         super.run();
 5         try{
 6             for (int i = 0; i < 500000; i++) {
 7                 if (this.interrupted()) {
 8                     System.out.println("should be stopped and exit");
 9                     throw new InterruptedException();
10                 }
11                 System.out.println("i=" + (i + 1));
12             }
13             System.out.println("this line cannot be executed. cause thread throws exception");//這行語句不會被執行!!!
14         }catch(InterruptedException e){
15             System.out.println("catch interrupted exception");
16             e.printStackTrace();
17         }
18     }
19 }

當MyThread執行緒檢測到中斷標識為true後，在第9行丟擲InterruptedException異常。這樣，該執行緒就不能再執行其他的正常語句了(如，第13行語句不會執行)。這裡表明：interrupt()方法有兩個作用，一個是將執行緒的中斷狀態置位(中斷狀態由false變成true)；另一個則是：讓被中斷的執行緒丟擲InterruptedException異常。

這是很重要的。這樣，對於那些阻塞方法(比如 wait() 和 sleep())而言，當另一個執行緒呼叫interrupt()中斷該執行緒時，該執行緒會從阻塞狀態退出並且丟擲中斷異常。這樣，我們就可以捕捉到中斷異常，並根據實際情況對該執行緒從阻塞方法中異常退出而進行一些處理。

比如說：執行緒A獲得了鎖進入了同步程式碼塊中，但由於條件不足呼叫 wait() 方法阻塞了。這個時候，執行緒B執行 threadA.interrupt()請求中斷執行緒A，此時執行緒A就會丟擲InterruptedException，我們就可以在catch中捕獲到這個異常並進行相應處理(比如進一步往上丟擲)

因此，上面就是一個採用丟擲異常的方式來結束執行緒的示例。儘管該示例的實用性不大。原因在 IBM的這篇博文中：我們 生吞了中斷。

在第14行，我們直接catch了異常，然後列印輸出了一下而已，呼叫棧中的更高層的程式碼是無法獲得關於該異常的資訊的。

第16行的e.printStackTrace()作用就相當於

“（僅僅記錄 InterruptedException 也不是明智的做法，因為等到人來讀取日誌的時候，再來對它作出處理就為時已晚了。）”---摘自參考博文

上面我們是在run()方法中丟擲異常，符合這裡描述的：

有時候丟擲 InterruptedException 並不合適，例如當由 Runnable 定義的任務呼叫一個
可中斷的方法時，就是如此。在這種情況下，不能重新丟擲 InterruptedException，但是
您也不想什麼都不做。當一個阻塞方法檢測到中斷並丟擲 InterruptedException 時，它
清除中斷狀態。如果捕捉到 InterruptedException 但是不能重新丟擲它，那麼應該保留
中斷髮生的證據，以便呼叫棧中更高層的程式碼能知道中斷，並對中斷作出響應。該任務可以
通過呼叫 interrupt() 以 “重新中斷” 當前執行緒來完成，如清單 3 所示。 -----“摘自參考博文”

因為，run方法是實現的Runnable介面中的方法。不能像下面這樣定義，也即上面所說的：“不能重新丟擲InterruptedException”。

        @Override
        public void run() throws InterruptedException{//這是錯誤的
          //do something...

因此，一個更好的解決方案是：呼叫 interrupt() 以 “重新中斷” 當前執行緒。改進MyThread類中catch異常的方式，如下：

 1 public class MyThread extends Thread {
 2     @Override
 3     public void run() {
 4         super.run();
 5         try{
 6             for (int i = 0; i < 500000; i++) {
 7                 if (this.interrupted()) {
 8                     System.out.println("should be stopped and exit");
 9                     throw new InterruptedException();
10                 }
11                 System.out.println("i=" + (i + 1));
12             }
13             System.out.println("this line cannot be executed. cause thread throws exception");
14         }catch(InterruptedException e){
15             /**這樣處理不好
16              * System.out.println("catch interrupted exception");
17              * e.printStackTrace();
18              */
19              Thread.currentThread().interrupt();//這樣處理比較好
20         }
21     }
22 }

這樣，就由 生吞異常 變成了 將 異常事件 進一步擴散了。

參考書籍：《Java多執行緒程式設計核心技術》