Java中出現線程中斷的原因有哪些

這篇文章將為大家詳細講解有關Java中出現線程中斷的原因有哪些，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

一、前言

大家肯定都使用過 Java 線程開發（Thread / Runnable），啟動一個線程的做法通常是：

new Thread(new Runnable(
 @Override
 public void run() {
  // todo sth...
 }
)).start();

然而線程退出，大家是如何做的呢？一般做法可能不外乎以下兩種：

• 設置一個標志位：true / false 來退出；

• 強制退出：thread.stop；（我相信，現在應該沒人會使用這種方式了，因為JDK也很早就廢棄了該方法）
  

可能還會有人提出，我可以用中斷來退出線程！ 我只能說：Too Young Too Simple！中斷并不會使得線程結束而退出，中斷（interrupt）只是喚醒被阻塞的線程而已。

本篇，我們就來好好的聊聊：線程中斷，以及如何正確的使用線程中斷，和正確的線程退出。

二、為何 Thread.stop 被廢棄

This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it 
has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the 
objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to 
other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply 
modifies some variable to indicate that the target thread should stop running. The target thread should check this 
variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop 
running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method 
should be used to interrupt the wait.

以上是官方 JDK 中的源碼注釋說明，其含義如下：

**Thread.stop 方法天生就不安全。**使用該方法來停止線程，將會導致其它因為監視器鎖『監視器我們在 synchronized 中就講過，是 Java 的內置鎖』而被鎖住的線程全部都解鎖！（本質的后果是：沒有檢查的 ThreadDeath 異常會在棧中傳播，因而使得監視器鎖解鎖）。如果任何一個被監視器鎖給鎖住的對象處于一個不一致的狀態，那么其被解鎖后將會被其它線程可見，潛在的結果是產生任何后果。**我們應該使用一個變量來代替使用 stop 方法，告訴目標線程退出『這里就是我們開頭所說的第一種方法，設置一個標志位』。**目標線程應該周期性的檢查這個變量，并根據這個變量來正確的退出 run 方法。如果目標線程處于阻塞/休眠狀態（如：使用 wait、sleep、yield 方法后，線程讓出了 CPU 使用權，進而阻塞/休眠），此時，該標志位變量將不會起作用，那么，應該使用 interrupt 方法來中斷目標線程的阻塞/休眠狀態，將其喚醒！

對于 ThreadDeath 對象，官方還有補充：

• 線程可以在幾乎任何地方拋出 ThreadDeath 異常。由于這一點，所有的同步方法和（代碼）塊將必須被考慮得事無巨細。

• 線程在清理第一個 ThreadDeath 異常的時候（在 catch 或 finally 語句中），可能會拋出第二個。清理工作將不得不重復直到到其成功。保障這一點的代碼將會很復雜。
  

所以，我們也別想著去 try-catch ThreadDeath Exception！

同樣，被廢棄的還有 Thread.resume 和 Thread.suspend。這倆方法有造成死鎖的危險：

• 使用suspend時，并不會釋放鎖；

• 如果存在某種情況要先獲取該鎖，再進行resume，那么就造成死鎖了；

• 
  

取代這兩方法的正確方式是：Object.wait 和 Object.notify ：

因為 Object.wait 進入阻塞時，會釋放鎖。

三、線程中斷的含義

Thread 中有三個與中斷相關的方法：

• 成員方法 interrupt()：設置線程中斷標志為 true ；

• 成員方法 isInterrupted()：獲取線程的中斷狀態，默認為 false，調用 interrupt() 后，該方法返回 true；

• 靜態方法 Thread.interrupted()：獲取線程的中斷狀態，并且清除中斷狀態（設置為 false）；
  

注：如果線程中斷后，連續兩次調用 Thread.interrupted()，第一次是 true & 清除狀態，第二次結果是 false。

3.1、初步了解

我們先來通過一個例子來初步了解 thread.interrupt ：

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread running...");
  }
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();

  Thread.sleep(50);
  System.out.println("interrupt thread");
  thread.interrupt();

  Thread.sleep(50);
  System.out.println("thread's status = " + thread.isInterrupted());
 }
}

輸出結果：

start thread
Thread running...
Thread running...
......
interrupt thread
Thread running...
Thread running...
......
thread's status = true
Thread running...
......

我們可以看到，即便我們調用了 thread.interrupt 方法，線程也并沒有退出，仍舊繼續運行。因此，這個例子證明了一點：我們并不能通過"我們所認為的"中斷來試圖"結束"正在運行的線程。

3.2、中斷即喚醒阻塞/休眠的線程

同樣，我們再來看一個例子：

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
    System.out.println("thread interrupted...");
   }

   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

輸出結果：

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
thread interrupted...
Thread run, total sleep = 3002(ms)
Thread will sleep 10s ------------------------- running
Thread run, total sleep = 10002(ms)
Thread will sleep 10s ------------------------- running

我們可以看到，線程啟動后，進入睡眠（10s），3秒后被中斷喚醒，執行完一個 while 后再次進入第二次睡眠（10s），然后周而復始。

3.3、一般標志位法退出線程

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);

 @Override
 public void run() {
  while (running.get()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  running.set(false);
  System.out.println("main exit");
 }
}

輸出結果：

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

我們通過使用一個 AtomicBoolean 變量來當作標志位，使得我們的線程能正常退出。 我們也可以判斷線程是否被中斷而選擇性的退出。

3.4、線程中斷退出

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (!Thread.currentThread().isInterrupted()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

輸出結果：

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

3.5、標志位 + 線程中斷結合

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);

 @Override
 public void run() {
  while (running.get()) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
    System.out.println("Interrupted... Todo other things then exit......");
    running.set(false);
    continue;
   }
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

輸出結果：

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
Interrupted... Todo other things then exit......
Thread exit

關于Java中出現線程中斷的原因有哪些就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。