在JAVA中，曾經使用stop方法來停止執行緒，然而，該方法具有固有的不安全性，因而已經被拋棄(Deprecated)。那麼應該怎麼結束一個程序呢？官方文件中對此有詳細說明：《為何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？》。在此引用stop方法的說明：

1. Why is Thread.stop deprecated? Because it is inherently unsafe. Stopping a thread causes it to unlock all the monitors that it has locked. (The monitors are unlocked as the ThreadDeath exception propagates up the stack.) If any of the objects previously protected by these monitors were in an inconsistent state, other threads may now view these objects in an inconsistent state. Such objects are said to be damaged. When threads operate on damaged objects, arbitrary behavior can result. This behavior may be subtle and difficult to detect, or it may be pronounced. Unlike other unchecked exceptions, ThreadDeath kills threads silently; thus, the user has no warning that his program may be corrupted. The corruption can manifest itself at any time after the actual damage occurs, even hours or days in the future. 大概意思是： 因為該方法本質上是不安全的。停止一個執行緒將釋放它已經鎖定的所有監視器（作為沿堆疊向上傳播的未檢查 ThreadDeath 異常的一個自然後果）。如果以前受這些監視器保護的任何物件都處於一種不一致的狀態，則損壞的物件將對其他執行緒可見，這有可能導致任意的行為。此行為可能是微妙的，難以察覺，也可能是顯著的。不像其他的未檢查異常，ThreadDeath異常會在後臺殺死執行緒，因此，使用者並不會得到警告，提示他的程式可能已損壞。這種損壞有可能在實際破壞發生之後的任何時間表現出來，也有可能在多小時甚至在未來的很多天後。 在文件中還提到，程式設計師不能通過捕獲ThreadDeath異常來修復已破壞的物件。具體原因見原文。 既然stop方法不建議使用，那麼應該用什麼方法來代理stop已實現相應的功能呢？ 1、通過修改共享變數來通知目標執行緒停止執行 大部分需要使用stop的地方應該使用這種方法來達到中斷執行緒的目的。 這種方法有幾個要求或注意事項： （1）目標執行緒必須有規律的檢查變數，當該變數指示它應該停止執行時，該執行緒應該按一定的順序從它執行的方法中返回。 （2）該變數必須定義為volatile，或者所有對它的訪問必須同步(synchronized)。 例如： 假如你的applet包括start,stop,run幾個方法：

1. private Thread blinker; 
2. publicvoid start() { 
3.     blinker = new Thread(this); 
4.     blinker.start(); 
5. } 
6. publicvoid stop() { 
7.     blinker.stop();  // UNSAFE!
8. } 
9. publicvoid run() { 
10.     Thread thisThread = Thread.currentThread(); 
11.     while (true) { 
12.         try { 
13.         thisThread.sleep(interval); 
14.         } catch (InterruptedException e){ 
15.         } 
16.         repaint(); 
17.     } 
18. } 

你可以使用如下方式避免使用Thread.stop方法：

1. private
   volatile Thread blinker; 
2. publicvoid stop() { 
3.     blinker = null; 
4. } 
5. publicvoid run() { 
6.     Thread thisThread = Thread.currentThread(); 
7.     while (blinker == thisThread) { 
8.         try { 
9.             thisThread.sleep(interval); 
10.         } catch (InterruptedException e){ 
11.         } 
12.         repaint(); 
13.     } 
14. } 

2、通過Thread.interrupt方法中斷執行緒 通常情況下，我們應該使用第一種方式來代替Thread.stop方法。然而以下幾種方式應該使用Thread.interrupt方法來中斷執行緒（該方法通常也會結合第一種方法使用）。 一開始使用interrupt方法時，會有莫名奇妙的感覺：難道該方法有問題？ API文件上說，該方法用於"Interrupts this thread"。請看下面的例子：

1. package com.polaris.thread; 
2. publicclass TestThread implements Runnable{ 
3.     boolean stop = false; 
4.     publicstaticvoid main(String[] args) throws Exception { 
5.         Thread thread = new Thread(new TestThread(),"My Thread"); 
6.         System.out.println( "Starting thread..." ); 
7.         thread.start(); 
8.         Thread.sleep( 3000 ); 
9.         System.out.println( "Interrupting thread..." ); 
10.         thread.interrupt(); 
11.         System.out.println("執行緒是否中斷：" + thread.isInterrupted()); 
12.         Thread.sleep( 3000 ); 
13.         System.out.println("Stopping application..." ); 
14.     } 
15.     publicvoid run() { 
16.         while(!stop){ 
17.             System.out.println( "My Thread is running..." ); 
18.             // 讓該迴圈持續一段時間，使上面的話列印次數少點
19.             long time = System.currentTimeMillis(); 
20.             while((System.currentTimeMillis()-time < 1000)) { 
21.             } 
22.         } 
23.         System.out.println("My Thread exiting under request..." ); 
24.     } 
25. } 

執行後的結果是： Starting thread... My Thread is running... My Thread is running... My Thread is running... My Thread is running... Interrupting thread... 執行緒是否中斷：true My Thread is running... My Thread is running... My Thread is running... Stopping application... My Thread is running... My Thread is running... …… 應用程式並不會退出，啟動的執行緒沒有因為呼叫interrupt而終止，可是從呼叫isInterrupted方法返回的結果可以清楚地知道該執行緒已經中斷了。那位什麼會出現這種情況呢？到底是interrupt方法出問題了還是isInterrupted方法出問題了？在Thread類中還有一個測試中斷狀態的方法（靜態的）interrupted，換用這個方法測試，得到的結果是一樣的。由此似乎應該是interrupt方法出問題了。於是，在網上有一篇文章：《 Java Thread.interrupt 害人！ 中斷JAVA執行緒》，它詳細的說明了應該如何使用interrupt來中斷一個執行緒的執行。 實際上，在JAVA API文件中對該方法進行了詳細的說明。該方法實際上只是設定了一箇中斷狀態，當該執行緒由於下列原因而受阻時，這個中斷狀態就起作用了： （1）如果執行緒在呼叫 Object 類的 wait()、wait(long) 或 wait(long, int) 方法，或者該類的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法過程中受阻，則其中斷狀態將被清除，它還將收到一個InterruptedException異常。這個時候，我們可以通過捕獲InterruptedException異常來終止執行緒的執行，具體可以通過return等退出或改變共享變數的值使其退出。 （2）如果該執行緒在可中斷的通道上的 I/O 操作中受阻，則該通道將被關閉，該執行緒的中斷狀態將被設定並且該執行緒將收到一個 ClosedByInterruptException。這時候處理方法一樣，只是捕獲的異常不一樣而已。 其實對於這些情況有一個通用的處理方法：

1. package com.polaris.thread; 
2. publicclass TestThread2 implements Runnable{ 
3.     boolean stop = false; 
4.     publicstaticvoid main(String[] args) throws Exception { 
5.         Thread thread = new Thread(new TestThread2(),"My Thread2"); 
6.         System.out.println( "Starting thread..." ); 
7.         thread.start(); 
8.         Thread.sleep( 3000 ); 
9.         System.out.println( "Interrupting thread..." ); 
10.         thread.interrupt(); 
11.         System.out.println("執行緒是否中斷：" + thread.isInterrupted()); 
12.         Thread.sleep( 3000 ); 
13.         System.out.println("Stopping application..." ); 
14.     } 
15.     publicvoid run() { 
16.         while(!stop){ 
17.             System.out.println( "My Thread is running..." ); 
18.             // 讓該迴圈持續一段時間，使上面的話列印次數少點
19.             long time = System.currentTimeMillis(); 
20.             while((System.currentTimeMillis()-time < 1000)) { 
21.             } 
22.             if(Thread.currentThread().isInterrupted()) { 
23.                 return; 
24.             } 
25.         } 
26.         System.out.println("My Thread exiting under request..." ); 
27.     } 
28. } 

因為呼叫interrupt方法後，會設定執行緒的中斷狀態，所以，通過監視該狀態來達到終止執行緒的目的。 總結：程式應該對執行緒中斷作出恰當的響應。響應方式通常有三種：（來自溫紹錦（暱稱：溫少）：http//www.cnblogs.com/jobs/）

注意：interrupted與isInterrupted方法的區別（見API文件）

引用一篇文章

當外部執行緒對某執行緒呼叫了thread.interrupt()方法後，java語言的處理機制如下：

如果該執行緒處在可中斷狀態下，（呼叫了xx.wait()，或者Selector.select(),Thread.sleep()等特定會發生阻塞的api），那麼該執行緒會立即被喚醒，同時會受到一個InterruptedException，同時，如果是阻塞在io上，對應的資源會被關閉。如果該執行緒接下來不執行“Thread.interrupted()方法（不是interrupt），那麼該執行緒處理任何io資源的時候，都會導致這些資源關閉。當然，解決的辦法就是呼叫一下interrupted()，不過這裡需要程式設計師自行根據程式碼的邏輯來設定，根據自己的需求確認是否可以直接忽略該中斷，還是應該馬上退出。

如果該執行緒處在不可中斷狀態下，就是沒有呼叫上述api，那麼java只是設定一下該執行緒的interrupt狀態，其他事情都不會發生，如果該執行緒之後會呼叫行數阻塞API，那到時候執行緒會馬會上跳出，並丟擲InterruptedException，接下來的事情就跟第一種狀況一致了。如果不會呼叫阻塞API，那麼這個執行緒就會一直執行下去。除非你就是要實現這樣的執行緒，一般高效能的程式碼中肯定會有wait()，yield()之類出讓cpu的函式，不會發生後者的情況。