Java ThreadInterrupt 方法詳解

一、ThreadInterrupt簡介

Java中的Interrupt機制允許線程請求終止另一個線程的執行。ThreadInterrupt()方法通常用於中斷阻塞的線程、循環等待的線程或執行複雜運算需要花費大量時間的線程。

實際上，ThreadInterrupt方法並不能直接停止一個線程，而是一種協作機制。具體地說，當一個線程被調用ThreadInterrupt後，線程知道它已被中斷，可以在合適的時候自行停止。這個機制需要線程自己去檢測是否被中斷，如果被中斷，則做出對應的處理動作。

二、ThreadInterrupt方法相關方法

Java中提供了幾個方法用於線程中斷相關操作：

1、isInterrupted()

isInterrupted()方法返回boolean值，用於判斷當前線程是否已被中斷，不會改變線程中斷狀態。

public boolean isInterrupted() 

2、interrupt()

interrupt()方法用於中斷線程，將線程中斷狀態設為true。如果線程處於一些方法的阻塞狀態（如sleep()、wait()、join()等），則會拋出InterruptedException異常，同時會將線程的中斷狀態複位為false。

public void interrupt() 

3、Thread.interrupted()

Thread.interrupted()方法用於返回當前線程的中斷狀態，並將中斷狀態設置為false。

public static boolean interrupted() 

三、如何使用ThreadInterrupt方法

1、基本用法

以下是一個簡單的示例，展示了如何使用ThreadInterrupt方法來中斷線程：

public class InterruptDemo{
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("Thread is running...");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    System.out.println("Thread is interrupted!");
                }
            }
        });
        thread.start();
        try {
            Thread.sleep(5000); // 主線程等待5秒後，中斷子線程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt(); // 中斷子線程
    }
}

在該示例中，我們創建了一個線程並啟動，該線程每秒鐘輸出一次信息。在主線程中等待5秒後，使用ThreadInterrupt方法中斷子線程。當線程處於等待狀態，如Thread.sleep()或Object.wait()等，如果線程中斷，那麼就會拋出InterruptedException異常。

2、如何讓線程中斷後退出

當線程在執行任務時被中斷，我們往往需要讓線程中斷後能夠安全退出，為此，我們需要讓線程在檢測到中斷狀態後自動退出，以下是一個示例：

public class SafeExitDemo {
    public static void main(String[] args) {
        Thread thread =new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    try {
                        System.out.println("Thread is running....");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println("Thread is interrupted!");
                        Thread.currentThread().interrupt();
                    }
                }
            }
        });
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        System.out.println("Main thread is finished!");
    }
}

在該示例中，當線程捕捉到InterruptedException異常時，我們使用Thread.currentThread().interrupt()手動將線程的中斷狀態設置為true，以便能夠讓線程安全退出。

3、如何在隊列（blockingQueue）中使用ThreadInterrupt方法

在使用阻塞隊列時，我們可能會遇到隊列已滿或空的情況下，線程就會被阻塞。為了能夠讓線程在阻塞狀態下被中斷並終止，我們可以使用ThreadInterrupt方法和ReentrantLock來實現：

public class BlockingQueueInterruptDemo {
    private static final int CAPACITY = 5;
    private static final ArrayBlockingQueue queue = new ArrayBlockingQueue(CAPACITY);
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread producer = new Thread(new Producer());
        Thread consumer = new Thread(new Consumer());
        producer.start();
        consumer.start();
        try {
            Thread.sleep(5000); // 主線程等待5秒後，中斷子線程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        producer.interrupt(); // 中斷生產者線程
        consumer.interrupt(); // 中斷消費者線程
    }

    static class Producer implements Runnable {

        @Override
        public void run() {
            int i = 0;
            while (!Thread.currentThread().isInterrupted()) {
                lock.lock();
                try {
                    if (queue.size() == CAPACITY) {
                        System.out.println("Queue is full, producer is waiting, size: " + queue.size());
                        queue.wait();
                    } else {
                        queue.add(++i);
                        System.out.println("Producer produce data: " + i + ", size: " + queue.size());
                        Thread.sleep(1000);
                        queue.notifyAll();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    static class Consumer implements Runnable {

        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                lock.lock();
                try {
                    if (queue.isEmpty()) {
                        System.out.println("Queue is empty, consumer is waiting, size: " + queue.size());
                        queue.wait();
                    } else {
                        Integer data = queue.poll();
                        System.out.println("Consumer consume data: " + data + ", size: " + queue.size());
                        Thread.sleep(1000);
                        queue.notifyAll();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}

在該示例中，我們設置了數組阻塞隊列的容量為5，如果生產者線程要向隊列中添加數據時遇到隊列已滿阻塞的情況，則會進入等待狀態，並釋放鎖。當隊列中有空位置時，則通知所有等待的線程，並重新獲得鎖進行生產。

同樣地，如果消費者線程在隊列為空的情況下遇到阻塞，則會進入等待狀態。當隊列中有數據時，消費者線程會取出數據進行消費，並通知所有等待的線程，並重新獲得鎖進行消費。

在主線程中等待5秒後，中斷生產者線程和消費者線程，線程中斷狀態為true，則線程會自行停止。

四、ThreadInterrupt方法的注意事項

在使用ThreadInterrupt方法時，需要注意以下事項：

1、ThreadInterrupt方法不能中斷正在運行的線程。

一旦線程開始執行，調用ThreadInterrupt方法將不能中斷它。只有當它進入到一些會導致阻塞的狀態時，才能進行中斷。

2、ThreadInterrupt方法會影響線程上下文

當線程被中斷時，有些線程不會立即停止，可能會在一個最佳停止時間（安全點）停止。此時，線程的上下文狀態就很重要了。線程上下文指的是線程執行一個代碼片段時它所在的程序的狀態，包括線程的寄存器、堆棧、內存等狀態。

3、ThreadInterrupt方法不能保證立即停止線程

中斷操作只是在請求中斷時，將線程的中斷標誌位設置為true。線程需要自行檢查自己的中斷標誌位，以決定是否可以安全退出。

五、總結

ThreadInterrupt方法是Java中實現線程中斷的一種機制。它允許一個線程中斷另一個線程的執行，並在一定程度上使線程停止執行。Java中的ThreadInterrupt方法提供了isInterrupted()、interrupt()和Thread.interrupted()三個方法用於線程的中斷狀態檢查、中斷狀態設置和中斷狀態獲取。

在使用ThreadInterrupt方法時需要注意，它不能中斷正在執行的線程，而是通過請求中斷標誌來協同線程完成中斷的動作。線程需要自行判斷中斷標誌位，只有在合適的時候自行停止執行，才能達到預期的效果。