Java中的線程中斷方法怎么用

本篇內容介紹了“Java中的線程中斷方法怎么用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

Java中的線程中斷

1 線程中斷相關方法介紹

Java多線程編程中的interrupt()方法、isInterrupted()方法和interrupted()方法都是跟線程中斷相關的方法，都非常重要。這三個方法名稱非常相似，不理解原理時容易混淆，這里分別介紹下，以加以區分。由于interrupt()方法和isInterrupted()方法都是實例方法(非類上的靜態方法)，因此我在前面加了個thread1，表示一個實例化的具體線程：

thread1.interrupt()方法

thread1.interrupt()方法用來中斷線程，所謂的中斷，大家可以通俗的理解為打斷。比如有兩個線程a和b，當線程a因為某些原因想打斷線程b時，a線程內部可以調用b.interrupt()。不過要注意，實現上是通過設置線程b的中斷狀態標記實現的。b線程代碼運行期間，可以在一個循環體內不斷的判斷該中斷狀態標記，以確認是否真正響應a的中斷請求(比如退出執行等等)。

thread1.isInterrupted()方法

thread1.isInterrupted()方法用來獲取一個線程的中斷狀態。比如有兩個線程a和b，當線程a因為某些原因想打斷線程b時，可以通過b.interrupt()對b進行中斷。在線程b內部，可以判斷自己的中斷狀態，是否是被中斷的，然后根據中斷狀態確認是否響應中斷請求(比如退出當前線程的循環體等等)。thread1.isInterrupted()方法內部直接調用了native方法，傳入的ClearInterrupted參數是false，表示不清空中斷狀態標記：

public boolean isInterrupted() {
  return isInterrupted(false);
}// ClearInterrupted表示是否清楚中斷狀態標記private native boolean isInterrupted(boolean ClearInterrupted);

因此調用完該方法后，中斷標志位不清除。

Thread.interrupted()方法

Thread.interrupted()是定義在Thread類上的靜態方法，用來判斷當前線程的中斷狀態，跟thread1.isInterrupted()不同的是，該方法返回中斷狀態之后，會復位(reset)中斷狀態標記，所謂的復位即恢復默認狀態，也可以說是清空中斷狀態標記。看Thread類源碼可以看到Thread.interrupted()方法實現非常簡單，內部直接調用了native方法，只不過ClearInterrupted參數傳的是true，表示清空中斷狀態標記：

public static boolean interrupted() {
  return currentThread().isInterrupted(true);
}// ClearInterrupted表示是否清楚中斷狀態標記private native boolean isInterrupted(boolean ClearInterrupted);

可以看出thread1.isInterrupted()和Thread.interrupted()的區別其實就在于獲取完中斷狀態標記之后，是否復位。大家可以根據需要進行選擇使用。

2 不考慮線程阻塞時如何優雅的停止一個線程

要想優雅的停止某個線程的運行，需要前面介紹的中斷機制。比如兩個線程a和b，當線程a想中斷線程b時，可以通過調用b.interrupt()方法，來設置線程b的中斷標記，以達到通知線程b的目的。而線程b需要不斷的檢查自己的中斷標記，以隨時響應其他線程的中斷，比如下面的實現所示：

public class TestMain {
    public static void main(String[] args) throws InterruptedException {
        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                int num = 0;
                while(true) {
                    if (Thread.interrupted()) {
                        break;
                    }
                    System.out.println("thread b running, num is:" + num++);
                }
            }
        });
        b.start();
        // 主線程sleep 1ms，讓線程b循環一小會
        Thread.sleep(1);
        // 中斷線程b
        b.interrupt();
    }
}

這里在主線程內新創建了一個線程b，線程b內部是一個循環體，每次循環開始都檢查一下中斷狀態，確認是否被中斷，如果被中斷了即退出循環，結束線程的執行。主線程sleep了1ms，讓線程b先循環幾次。接著主線程通過b.interrupt()對線程b進行中斷。運行程序可以看到輸出如下(不同機器運行結果不一樣)：

thread b running, num is:0thread b running, num is:1thread b running, num is:2...
thread b running, num is:25thread b running, num is:26thread b running, num is:27Process finished with exit code 0

可以看到主線程成功的中斷了線程b。當然，主線程之所以能成功的中斷線程b，是因為線程b一直在檢查自己的中斷狀態(如果線程b太自我，不考慮其他線程，只考慮自己運行，那主線程就無法成功打斷線程b了)。

3 考慮線程阻塞時如何優雅的停止一個線程

前面我們成功的在主線程中中斷了線程b，然后如果線程b中存在阻塞，比如下面的代碼所示，線程b在sleep時被主線程中斷：

public class TestMain {
    public static void main(String[] args) throws InterruptedException {
        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                int num = 0;
                while(true) {
                    if (Thread.interrupted()) {
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // Thread.currentThread().interrupt();
                        e.printStackTrace();
                    }
                    System.out.println("thread b running, num is:" + num++);
                }
            }
        });
        b.start();
        // 主線程sleep5.5秒，讓線程b循環5次
        Thread.sleep(5500);
        // 中斷線程b
        b.interrupt();
    }
}

這時線程b會拋出InterruptedException異常，上面的代碼中我們僅僅打印了下該異常，相當于什么都沒做。運行該代碼結果如下：

thread b running, num is:0thread b running, num is:1thread b running, num is:2thread b running, num is:3thread b running, num is:4java.lang.InterruptedException: sleep interrupted
  at java.lang.Thread.sleep(Native Method)
  at test.TestMain$1.run(TestMain.java:25)
  at java.lang.Thread.run(Thread.java:748)
thread b running, num is:5thread b running, num is:6thread b running, num is:7thread b running, num is:8thread b running, num is:9...

可以看出，主線程未能成功中斷線程b。

3.1 InterruptedException異常介紹

線程內調用wait，join，sleep時都會進入阻塞狀態。當線程處于阻塞狀態時被中斷，這時線程就會拋出InterruptedException異常，其實大家可以通俗的理解為一種通知即可。以sleep方法為例，大家可以按如下模擬實現來理解(底層是native實現)：

public static void sleep(long millis) throws InterruptedException 
{
    while (/* still waiting for millis to become zero */) 
    {
        if (Thread.interrupted())
        {
            throw new InterruptedException();
        }
        // Keep waiting
    }
}

有了InterruptedException異常通知，線程就可以在阻塞時立即知道被中斷了，進而采取一定的措施響應中斷。需要注意的一點是，由于拋出了InterruptedException異常，因此不會在設置中斷標志位。

3.2 考慮線程阻塞時如何優雅的停止一個線程

理解了InterruptedException異常，我們就可以在線程即使發生阻塞時也能成功進行中斷了，如下所示：

public class TestMain {
    public static void main(String[] args) throws InterruptedException {
        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                int num = 0;
                while(true) {
                    if (Thread.interrupted()) {
                        break;
                    }
                    try {
                        Thread.sleep(1000); // 用sleep來模擬線程的執行
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt(); // 注意這里是重點！
                    }
                    System.out.println("thread b running, num is:" + num++);
                }
            }
        });
        b.start();
        // 主線程sleep5.5秒，讓線程b先循環5次
        Thread.sleep(5500);
        // 中斷線程b
        b.interrupt();
    }
}

這里我們在檢查到InterruptedException異常時，重新設置了中斷標志位，這樣下次循環一開始時，即可判斷被中斷了，進而退出循環體。當然我們可以在InterruptedException異常catch時直接退出。

“Java中的線程中斷方法怎么用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！