Java 线程中断机制详解

草稿难度：高级#Java#JUC

原文：CSDN（历史文章导入，当前状态为草稿）

1. 引言：为什么需要线程中断？

在并发编程中，我们经常需要协调不同线程的执行。
有时，一个线程需要通知另一个线程停止其当前正在执行的任务。
你可能会想到一些看似直接的方法，比如调用 Thread.stop() 或 Thread.suspend()。然而，这些方法已被明确废弃 (Deprecated)，因为它们存在严重的缺陷：

Thread.stop(): 强制终止线程，不给线程任何清理资源（如释放锁、关闭文件、网络连接等）的机会。这可能导致对象状态不一致，引发难以预料的错误。想象一下，一个线程正在修改共享数据，只修改了一半就被 stop() 了，这会留下一个“残缺”的数据结构，其他线程使用时就会出错。
Thread.suspend() 和 Thread.resume(): 容易导致死锁。如果一个线程在持有锁的情况下被 suspend()，它将永远不会释放该锁，其他需要该锁的线程将无限期等待。

为了解决这些问题，Java 引入了线程中断 (Thread Interruption) 机制。线程中断并非强制终止线程，而是一种协作式的通信机制。
它允许一个线程向另一个线程发送一个“请求停止”的信号，而被请求的线程可以自行决定如何以及何时响应这个信号，从而有机会进行必要的清理工作，实现“优雅地”停止。
请在具备 Java 基础和多线程的基本概念（如 Thread 类的使用、Runnable 接口、锁等）知识后阅读体验最佳。

2. 核心概念：中断状态与关键方法

理解线程中断的关键在于掌握它的核心组成部分：

中断状态标志位
操作标志位
检查标志位

2.1 中断状态 (Interrupt Status)

每个 Java Thread 对象内部都有一个 boolean 类型的中断状态 (interrupt status) 标志位。默认情况下，这个标志位是 false。当中断发生时，这个标志位会被设置为 true。

这个状态位是线程中断机制的核心，后续的所有操作都围绕着检查和修改这个状态位进行。

2.2 `thread.interrupt()` 方法

作用: 这是发起中断请求的主要方法。当你调用一个线程实例 t 的 t.interrupt() 方法时，虚拟机会尝试设置线程 t 的中断状态位为 true。
特性:
1. 设置标志位: 如果目标线程当前没有因为调用 Object.wait(), Thread.sleep(), Thread.join() (及其重载版本) 而阻塞，那么调用 interrupt() 仅仅是将其内部的中断标志位设置为 true。线程不会立即停止，它会继续执行后续代码。
2. 唤醒阻塞并抛出异常: 如果目标线程正因为调用上述阻塞方法（wait, sleep, join）而处于阻塞状态，那么调用 interrupt() 不仅会设置中断标志位，还会立即唤醒该线程，并使其抛出 InterruptedException 异常。特别注意：在抛出 InterruptedException 的同时，JVM 会清除该线程的中断标志位，即将其重新设置为 false！ 这是 InterruptedException 的一个非常关键的特性。
3. 对 I/O 阻塞的影响: 如果线程阻塞在可中断的 I/O 操作上（例如 java.nio.channels.InterruptibleChannel），调用 interrupt() 通常也会导致该 I/O 调用立即返回，并抛出相应的异常（如 java.nio.channels.ClosedByInterruptException），同时设置中断状态。但对于传统的阻塞 I/O（java.io 包），interrupt() 通常不起作用（详见后续“中断与不可中断的阻塞”章节）。
4. 对 synchronized 阻塞的影响: 如果线程因为等待 synchronized 锁而阻塞，调用 interrupt() 不会有任何效果，线程会继续等待锁，中断状态会被设置。
5. 对 Lock.lock() 阻塞的影响: 如果线程因为调用 Lock.lock() 而阻塞，调用 interrupt() 不会唤醒线程，但中断状态会被设置。如果希望锁的获取可以被中断，应该使用 Lock.lockInterruptibly()。

源码]:

public void interrupt() {
    if (this != Thread.currentThread()) // 检查权限
        checkAccess();

    synchronized (blockerLock) { // 同步处理，防止竞争条件
        Interruptible b = blocker; // blocker 用于记录导致线程阻塞的对象 (如 InterruptibleChannel)
        if (b != null) {
            // 设置中断状态位 (native 方法实现)
            interrupt0(); // 关键：设置 native 层的中断状态
            // 如果线程阻塞在 InterruptibleChannel 上，中断该 channel
            b.interrupt(this); // 调用 Channel 的中断逻辑，可能导致抛出 ClosedByInterruptException
            return;
        }
    }
    // 如果没有阻塞在 InterruptibleChannel 上，仅设置中断状态位
    interrupt0(); // 关键：设置 native 层的中断状态
}

// interrupt0() 是一个 native 方法，它的具体实现依赖于 JVM 和操作系统。
// 其核心作用是：
// 1. 设置线程内部的中断标志位。
// 2. 如果线程正处于 sleep/wait/join 等状态，则唤醒它。
private native void interrupt0();


+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15
+ 16
+ 17
+ 18
+ 19
+ 20
+ 21
+ 22
+ 23
+ 24

解释: interrupt() 方法首先进行权限检查。然后，它会检查线程是否因为阻塞在某个 Interruptible 对象（通常是 NIO Channel）上。如果是，它会调用本地方法 interrupt0() 来设置底层的中断状态，并调用 Interruptible 对象的 interrupt() 方法来中断 I/O 操作。如果线程没有阻塞在 Interruptible 上，它就只调用 interrupt0() 来设置中断状态。这个本地方法 interrupt0() 负责实际设置线程的中断标志，并且如果线程当前正在 sleep, wait 或 join，则会唤醒该线程（进而导致 InterruptedException）。

2.3 `thread.isInterrupted()` 方法

作用: 检查目标线程的中断状态位。
特性:
1. 只读检查: 它仅仅返回目标线程当前的中断状态（true 或 false），不会修改中断状态位。
2. 实例方法: 需要通过线程实例来调用，例如 myThread.isInterrupted()。
使用场景: 这是在线程内部检查自己是否被中断的最常用方式，特别是在循环任务中。

源码浅析 (基于 OpenJDK):

public boolean isInterrupted() {
    // isInterrupted(false) 表示不清除中断状态
    return isInterrupted(false);
}

// 内部方法，由 native 实现
// 参数 clearInterrupted 表示是否在检查后清除中断状态
private native boolean isInterrupted(boolean clearInterrupted);


+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9

解释: isInterrupted() 方法内部调用了一个本地方法 isInterrupted(boolean clearInterrupted)，并传递 false 作为参数。这个 false 告诉本地方法：在检查中断状态后，不要清除它。因此，isInterrupted() 是一个只读操作。

2.4 `Thread.interrupted()` 方法 (静态方法)

作用: 检查当前正在执行该方法的线程的中断状态，并清除该状态。
特性:
1. 检查并清除: 这是此方法与 isInterrupted() 最本质的区别。它首先检查当前线程的中断状态，然后立即将该中断状态位重置为 false。
2. 静态方法: 直接通过 Thread 类调用：Thread.interrupted()。它作用于调用这个方法的线程本身。
3. 副作用: 因为它会清除中断状态，连续两次调用 Thread.interrupted()，如果第一次返回 true，第二次几乎肯定返回 false（除非在两次调用之间线程又被中断了）。
使用场景: 通常在捕获 InterruptedException 后，如果想在处理异常的同时再次检查中断状态（虽然不常见，因为 InterruptedException 本身就表明了中断），或者在某些特定的中断处理逻辑中需要清除状态时使用。但大多数情况下，推荐使用 isInterrupted()。

源码:

public static boolean interrupted() {
    // isInterrupted(true) 表示检查后清除中断状态
    // 注意：这里调用的是 currentThread() 的 isInterrupted(true)
    return currentThread().isInterrupted(true);
}

// 内部方法，由 native 实现
// 参数 clearInterrupted 表示是否在检查后清除中断状态
private native boolean isInterrupted(boolean clearInterrupted);


+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10

解释: 静态方法 interrupted() 内部获取当前线程 (currentThread())，然后调用其本地方法 isInterrupted(boolean clearInterrupted)，并传递 true 作为参数。这个 true 告诉本地方法：在检查中断状态后，必须清除它（将其设置为 false）。

2.5 `isInterrupted()` vs `Thread.interrupted()` 对比

特性	`thread.isInterrupted()`	`Thread.interrupted()`
类型	实例方法 (`myThread.isInterrupted()`)	静态方法 (`Thread.interrupted()`)
作用对象	调用该方法的 `thread` 实例	当前执行 `Thread.interrupted()` 的线程
清除状态	否 (No)	是 (Yes)
常用场景	在循环中检查自身是否被中断	处理 `InterruptedException` 时或特殊场景需要清除状态

理解难点: 初学者很容易混淆这两个方法。关键记住：

isInterrupted() 是实例方法，不改变状态，用于检查。
Thread.interrupted() 是静态方法，改变状态（清除），作用于当前线程。

在普通的任务循环中检查中断信号时，几乎总是应该使用 isInterrupted()。如果你错误地使用了 Thread.interrupted()，并且中断碰巧发生，第一次检查会返回 true，但同时状态被清除了，下一次循环检查时就会返回 false，导致你的线程无法正确停止。

2.6 `InterruptedException` 异常

本质: 它是一个受检异常 (Checked Exception)，继承自 Exception。
抛出时机: 当一个线程因为调用了 Object.wait(), Thread.sleep(), Thread.join() 等方法而进入阻塞状态时，如果其他线程调用了该阻塞线程的 interrupt() 方法，那么阻塞调用会立即被唤醒并抛出 InterruptedException。某些可中断的 NIO 操作也会在中断时抛出类似异常。
中断状态清除: 如前所述，当 JVM 抛出 InterruptedException 时，它会自动清除线程的中断状态位（设置为 false）。这是一个非常重要的行为！
为什么需要处理: 因为它是受检异常，编译器强制你必须捕获或声明抛出它。更重要的是，它传递了一个明确的信号：“你的线程被请求中断了”。忽略这个信号（例如，捕获后什么都不做）通常是错误的做法，会导致中断请求丢失。

3. 如何正确响应中断 (Responding to Interrupts)

仅仅调用 interrupt() 是不够的，目标线程需要有相应的逻辑来检测和响应这个中断信号。

3.1 在任务代码中检查中断状态

如果你的线程执行的是一个循环任务或者包含多个步骤的计算，你应该在合适的时机（例如循环的开始处或耗时操作之前）检查中断状态。

class MyTask implements Runnable {
    @Override
    public void run() {
        // 推荐使用 isInterrupted()
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 1. 执行工作单元
                System.out.println("正在执行任务...");
                doWorkUnit();

                // 2. 如果任务包含可中断的阻塞操作
                //    例如，等待某个条件或短暂休眠
                Thread.sleep(100); // sleep 是可中断的

            } catch (InterruptedException e) {
                // (重要!) sleep 被中断会进入这里
                System.out.println("收到中断信号 (来自 InterruptedException)，准备退出...");
                // 1. 恢复中断状态 (最佳实践)
                Thread.currentThread().interrupt();
                // 2. 清理资源 (如果需要)
                cleanup();
                // 3. 终止循环
                break; // 或 return
            } catch (Exception e) {
                // 处理其他异常
                System.err.println("发生其他错误: " + e.getMessage());
                // 根据情况决定是否也应该中断或退出
            }
        }
        System.out.println("任务执行完毕或被中断退出。");
    }

    private void doWorkUnit() {
        // 模拟执行一些工作
        long startTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - startTime < 50) {
            // 模拟耗时计算
            Math.sqrt(Math.random());
        }
    }

    private void cleanup() {
        System.out.println("执行清理工作...");
    }
}

public class InterruptCheckExample {
    public static void main(String[] args) throws InterruptedException {
        Thread taskThread = new Thread(new MyTask());
        taskThread.start();

        // 让任务运行一段时间
        Thread.sleep(500);

        System.out.println("主线程：发送中断请求...");
        taskThread.interrupt(); // 请求中断

        taskThread.join(); // 等待任务线程结束
        System.out.println("主线程：任务线程已结束。");
    }
}

在上面的例子中：

循环条件 !Thread.currentThread().isInterrupted() 用于检查中断状态。
Thread.sleep(100) 是一个可中断的阻塞方法。如果在此期间 taskThread.interrupt() 被调用，sleep() 会抛出 InterruptedException。
catch (InterruptedException e) 块是处理中断的关键。

3.2 处理 `InterruptedException` 的策略

当你的代码调用了可中断的阻塞方法（如 sleep, wait, join, BlockingQueue.take 等）并捕获到 InterruptedException 时，你有几种处理策略：

策略一：恢复中断状态并退出/处理 (推荐)

这是最推荐的做法，特别是当你的代码是一个库或框架的一部分，或者当前方法不是线程任务的顶层时。因为捕获 InterruptedException 时中断状态已被清除，如果不恢复它，上层调用栈就无法得知中断的发生。

public void someMethod() {
    try {
        while (!Thread.currentThread().isInterrupted()) {
            // ... 做一些工作 ...
            blockingOperation(); // 这是一个可能抛出 InterruptedException 的方法
        }
    } catch (InterruptedException e) {
        // 捕获到中断异常

        // 1. (关键!) 恢复中断状态
        // 让调用本方法的上层代码也能知道发生了中断
        Thread.currentThread().interrupt();

        // 2. 执行当前层级的清理
        cleanupResources();

        // 3. 可以选择退出当前方法或任务
        //    - 直接 return
        //    - 或者抛出自定义异常包装中断信息
        //    - 或者简单地结束循环 (如果是在循环的 catch 块中)
        System.out.println("方法 someMethod 检测到中断，恢复状态并准备退出。");
        // 例如，如果是 run() 方法，可以直接 return 或 break 循环
    }
}

private void blockingOperation() throws InterruptedException {
    Thread.sleep(1000); // 模拟可中断的阻塞操作
}

private void cleanupResources() {
    System.out.println("清理 someMethod 相关资源...");
}

为什么恢复状态很重要？ 假设 someMethod() 被另一个方法 outerMethod() 调用，而 outerMethod() 也依赖中断信号来停止。如果 someMethod() 捕获了 InterruptedException 但没有恢复状态，outerMethod() 在 someMethod() 返回后调用 isInterrupted() 将得到 false，从而无法正确响应中断。

策略二：向上抛出 `InterruptedException`

如果当前方法不适合处理中断（例如，它只是一个工具方法或中间层），可以将异常直接向上抛给调用者处理。这需要你的方法签名包含 throws InterruptedException。

// 当前方法不知道如何处理中断，将责任交给上层
public void processData() throws InterruptedException {
    // ... 一些准备工作 ...

    // 调用可能阻塞的方法，不捕获 InterruptedException
    receiveAndProcessMessage(); // 假设此方法声明了 throws InterruptedException

    // ... 后续处理 ...
}

// 模拟接收消息的方法，它可能会阻塞
private void receiveAndProcessMessage() throws InterruptedException {
    System.out.println("等待接收消息...");
    // 模拟阻塞等待，例如从队列取数据
    Thread.sleep(5000); // 如果在这里被中断，异常会抛给 processData()
    System.out.println("收到并处理了消息。");
}

// 调用者负责处理
public void run() {
    try {
        processData();
    } catch (InterruptedException e) {
        // 上层调用者捕获并处理中断
        Thread.currentThread().interrupt(); // 同样建议恢复状态
        System.out.println("任务 run() 检测到中断，进行清理并退出。");
        // 清理...
    }
}

这种方式将处理中断的责任沿着调用栈向上传递，直到某个合适的层级进行处理。

策略三：捕获并终止任务 (仅在顶层任务逻辑中适用)

如果捕获 InterruptedException 的地方就是线程任务的最高层逻辑（例如 Runnable 的 run() 方法），并且你知道中断意味着整个任务应该结束，那么可以直接进行清理并终止。

@Override
public void run() {
    try {
        while (true) { // 或者使用 !isInterrupted()
            System.out.println("执行核心循环...");
            performTaskStep(); // 包含可能抛出 InterruptedException 的操作
        }
    } catch (InterruptedException e) {
        // 捕获中断，认为是任务结束信号
        System.out.println("任务 run() 被中断，执行最终清理并退出。");
        finalCleanup();
        // 不需要恢复中断状态，因为任务即将结束，没有上层需要检查状态了
        // 直接从 run() 方法返回即可结束线程
    } finally {
        // 确保即使发生其他异常也能执行部分清理
        // additionalCleanupInFinally();
    }
}

private void performTaskStep() throws InterruptedException {
    System.out.println("执行步骤，可能阻塞...");
    Thread.sleep(200);
}

private void finalCleanup() {
    System.out.println("执行最终的资源清理...");
}

不推荐：捕获并忽略

绝对不要这样做：

// 错误示范：吞掉中断异常
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // 什么都不做，或者只打印日志
    // e.printStackTrace(); // 打印日志也不够！
}
// 继续执行后续代码...

这种做法被称为“吞掉 (swallowing)”中断异常。它会导致中断信号丢失，使得发起中断的线程无法得知目标线程是否真正响应了中断，目标线程也可能无法按预期停止，导致程序行为异常或资源泄露。

4. 发起中断的常见方式

除了直接调用 thread.interrupt()，还有其他一些场景和 API 会间接地使用中断机制。

4.1 直接调用 `thread.interrupt()`

这是最基本、最直接的方式，适用于你持有目标线程 Thread 对象引用的情况。

Thread worker = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("工作...");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复状态
            break;
        }
    }
    System.out.println("工人线程结束。");
});
worker.start();

// 主线程等待一段时间后发起中断
Thread.sleep(500);
System.out.println("主线程：中断工人线程！");
worker.interrupt();

4.2 `ExecutorService` 和 `Future`

当你使用 Java 的线程池 (ExecutorService) 时，管理线程生命周期（包括中断）通常更加规范。

Future<?> future = executor.submit(task);: 提交任务后会返回一个 Future 对象，代表异步任务的结果。
future.cancel(boolean mayInterruptIfRunning): Future 接口提供了 cancel 方法来取消任务。
- mayInterruptIfRunning = true: 如果任务已经在运行，cancel(true) 会尝试调用任务线程的 interrupt() 方法来中断它。这是实现协作式取消的关键。
- mayInterruptIfRunning = false: 如果任务已经在运行，cancel(false) 不会去中断线程，它只会将 Future 的状态标记为“已取消”，阻止尚未开始的任务启动，但不会影响正在运行的任务。
ExecutorService.shutdown(): 启动有序关闭。不再接受新任务，但会等待已经提交的任务（包括正在运行和在队列中等待的）执行完成。不会主动中断正在运行的任务。
ExecutorService.shutdownNow(): 尝试立即停止所有活动执行的任务，暂停处理等待的任务，并返回等待执行的任务列表。为了停止活动任务，shutdownNow() 会遍历线程池中的工作线程并调用每个线程的 interrupt() 方法。因此，你的任务代码必须能正确响应中断才能被 shutdownNow() 有效停止。

import java.util.concurrent.*;

public class FutureCancelExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        System.out.println("提交任务...");
        Future<?> future = executor.submit(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("任务运行中...");
                    Thread.sleep(200); // 模拟工作，并允许中断
                }
            } catch (InterruptedException e) {
                // 正确处理中断
                System.out.println("任务捕获到 InterruptedException，恢复状态并退出。");
                Thread.currentThread().interrupt(); // 恢复中断状态
            } finally {
                System.out.println("任务执行结束。");
            }
        });

        // 让任务运行一会儿
        Thread.sleep(1000);

        System.out.println("主线程：尝试取消任务 (允许中断)...");
        // 使用 cancel(true) 来中断正在运行的任务
        boolean cancelled = future.cancel(true);
        System.out.println("任务是否成功取消 (或已完成/已取消)？ " + cancelled);
        System.out.println("Future isCancelled: " + future.isCancelled());
        System.out.println("Future isDone: " + future.isDone()); // isDone() 在取消后也为 true

        // 关闭 ExecutorService
        executor.shutdown();
        if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
            System.err.println("ExecutorService 未能在5秒内终止，尝试强制关闭...");
            executor.shutdownNow();
        }
        System.out.println("主线程结束。");
    }
}

4.3 基于超时的中断

某些场景下，我们可能希望在操作超时后中断相关线程。这通常需要结合超时机制和手动调用 interrupt()。

thread.join(long millis): 等待目标线程 thread 终止，但最多等待 millis 毫秒。如果超时，join 方法会返回，此时可以检查线程是否还在活动 (isAlive())，如果是，则手动调用 interrupt()。

Thread longRunning = new Thread(() -> { /* ... 长时间任务 ... */ });
longRunning.start();
try {
    longRunning.join(5000); // 最多等待5秒
    if (longRunning.isAlive()) {
        System.out.println("任务超时，发送中断请求...");
        longRunning.interrupt();
    }
} catch (InterruptedException e) {
    // join 本身也可能被中断
    Thread.currentThread().interrupt();
    System.out.println("等待线程 join 时被中断...");
    // 可能也需要中断 longRunning 线程
    longRunning.interrupt();
}


+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+ 7
+ 8
+ 9
+ 10
+ 11
+ 12
+ 13
+ 14
+ 15

Lock.tryLock(long time, TimeUnit unit): 尝试在指定时间内获取锁。如果超时未能获取锁，可以根据业务逻辑决定是否中断当前线程或其他相关线程。
BlockingQueue.poll(long timeout, TimeUnit unit) / offer(E e, long timeout, TimeUnit unit): 带超时的阻塞队列操作。如果超时，可以根据需要发起中断。

需要注意的是，这些超时机制本身不直接导致中断，它们只是提供了一个判断超时的点，你需要在超时发生后显式地调用 interrupt() 来发起中断请求。

5. 中断与不可中断的阻塞 (Interruptible vs. Uninterruptible Blocking)

并非所有的阻塞操作都能响应 interrupt() 调用。理解哪些阻塞是可中断的，哪些是不可中断的，对于设计健壮的并发程序至关重要。

5.1 可中断的阻塞 (Interruptible Blocking)

这些操作在阻塞期间如果线程被中断，会抛出 InterruptedException (或类似的与中断相关的异常) 并唤醒线程。

Object.wait()
Thread.sleep()
Thread.join()
java.util.concurrent.locks.Lock.lockInterruptibly() (显式请求可中断的锁获取)
java.util.concurrent.locks.Condition.await()
java.util.concurrent.BlockingQueue 的 put() 和 take() 方法
java.util.concurrent.CountDownLatch.await()
java.util.concurrent.CyclicBarrier.await()
java.util.concurrent.Semaphore.acquire()
java.nio.channels.Selector.select() (以及其他 NIO InterruptibleChannel 上的阻塞操作，可能抛出 ClosedByInterruptException)

当线程阻塞在这些方法上时，可以通过调用 interrupt() 来“叫醒”它们。

5.2 不可中断的阻塞 (Uninterruptible Blocking)

这些操作在阻塞期间不会响应 interrupt() 调用。即使线程的中断状态被设置为 true，它们也会继续阻塞，直到阻塞条件解除。

synchronized 关键字获取锁: 如果线程因为等待进入 synchronized 代码块或方法而阻塞，调用 interrupt() 无效，线程会一直等待直到获取锁。中断状态会被设置，但线程不会被唤醒。
java.util.concurrent.locks.Lock.lock(): ReentrantLock 等 Lock 实现的 lock() 方法是不可中断的。如果需要可中断的锁获取，必须使用 lockInterruptibly()。
传统的阻塞 I/O (java.io.*): 大部分 java.io 包下的阻塞方法（如 InputStream.read(), OutputStream.write() 在网络或文件上的操作）通常是不可中断的。线程会一直阻塞在 I/O 调用上，直到 I/O 操作完成、出现错误或流被关闭。调用 interrupt() 仅设置中断状态，不会唤醒线程。
某些 JVM 内部操作

5.3 如何处理不可中断的阻塞？

如果你的线程可能阻塞在不可中断的操作上，并且你需要一种方法来停止它，那么 interrupt() 可能不够用。你需要采取其他策略：

对于 I/O 阻塞:
- 最好的办法通常是关闭底层的资源。例如，如果你有一个线程阻塞在 SocketInputStream.read() 上，可以在另一个线程中调用该 Socket 的 close() 方法。关闭 Socket 会导致阻塞在 read() 上的线程抛出 SocketException (通常是 “Socket closed” 或类似消息)，从而使其退出阻塞状态。
- 使用 NIO (java.nio) 代替传统的 java.io。NIO 的 Channel 通常是可中断的 (InterruptibleChannel)。当阻塞在 NIO Channel 上的线程被 interrupt() 时，Channel 会被关闭，并且阻塞的操作会抛出 ClosedByInterruptException。
对于 synchronized 阻塞:
- 没有直接的方法中断等待 synchronized 锁的线程。
- 避免长时间持有锁: 设计锁的粒度要小，尽量减少锁的持有时间。
- 使用 java.util.concurrent.locks.Lock: 改用 ReentrantLock 等 JUC 包中的锁，并使用 tryLock() 或 lockInterruptibly() 来代替 synchronized，这样就可以响应中断或进行超时控制。
- 协作式取消: 结合使用 volatile 标志位。等待锁的线程在获取锁之后，还需要检查一个 volatile boolean cancelled 标志，如果标志为 true，则立即释放锁并退出。
对于 Lock.lock() 阻塞:
- 始终优先考虑使用 lock.lockInterruptibly()，除非你明确需要不可中断的锁获取语义（这种情况很少见）。

理解难点: 很多开发者默认 interrupt() 可以中断一切阻塞，这是一个常见的误解。记住 synchronized 和传统 IO 阻塞是中断的“盲区”。

6. 最佳实践和注意事项

中断优先: 始终将线程中断作为首选的、标准的线程间“请求停止”的协作机制。避免使用已废弃的 stop(), suspend()。
正确处理 InterruptedException: 这是关键。要么恢复中断状态 (Thread.currentThread().interrupt())，要么向上抛出。永远不要“吞掉”它。
isInterrupted() vs interrupted(): 在循环检查或普通逻辑中，使用 isInterrupted()。仅在确实需要清除状态的特殊场景下使用 Thread.interrupted()。
任务代码需响应中断: 发起中断只是第一步，任务代码（Runnable/Callable）必须包含检查中断状态或处理 InterruptedException 的逻辑才能真正停止。
处理不可中断阻塞: 识别代码中的不可中断阻塞点，并设计替代的停止策略（如关闭资源、使用 JUC Lock、NIO 等）。
库/框架代码要谨慎: 如果你编写的是供他人使用的库或框架代码，通常不应自行决定中断的处理方式。最佳做法是恢复中断状态或向上抛出 InterruptedException，将决定权交给调用者。
中断的语义: interrupt() 的核心语义是“请求停止”。不要滥用它作为线程间的通用事件通知机制，这会使代码意图混淆。对于通用的线程间通信，应使用 wait/notify/notifyAll, Condition, BlockingQueue 等更合适的工具。
资源清理: 确保在响应中断退出时，执行必要的资源清理操作（关闭文件、释放锁、回滚事务等），通常在 finally 块或 catch 块中完成。

7. 示例：优雅关闭的生产者-消费者模型

下面是一个简化的生产者-消费者示例，展示如何使用中断来请求生产者和消费者线程停止。

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ProducerConsumerInterrupt {

    private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
    private static final ExecutorService executor = Executors.newFixedThreadPool(2);
    private static volatile boolean running = true; // 控制运行状态

    // 生产者
    static class Producer implements Runnable {
        private AtomicInteger count = new AtomicInteger(0);

        @Override
        public void run() {
            System.out.println("生产者启动...");
            try {
                while (running && !Thread.currentThread().isInterrupted()) {
                    int item = count.incrementAndGet();
                    System.out.println("生产者: 准备生产 " + item);
                    // put 方法是可中断的
                    queue.put(item);
                    System.out.println("生产者: 成功生产 " + item + ", 队列大小: " + queue.size());
                    // 稍微慢一点，便于观察
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                System.out.println("生产者: 收到中断信号 (InterruptedException)，停止生产。");
                // 恢复中断状态，尽管在这里不是必须的，因为线程即将结束
                Thread.currentThread().interrupt();
            } finally {
                System.out.println("生产者线程结束。");
            }
        }
    }

    // 消费者
    static class Consumer implements Runnable {
        @Override
        public void run() {
            System.out.println("消费者启动...");
            try {
                while (running && !Thread.currentThread().isInterrupted()) {
                    System.out.println("消费者: 等待消费...");
                    // take 方法是可中断的
                    Integer item = queue.take();
                    System.out.println("消费者: 成功消费 " + item + ", 队列大小: " + queue.size());
                    // 模拟消费耗时
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                System.out.println("消费者: 收到中断信号 (InterruptedException)，停止消费。");
                Thread.currentThread().interrupt();
            } finally {
                System.out.println("消费者线程结束。");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Future<?> producerFuture = executor.submit(new Producer());
        Future<?> consumerFuture = executor.submit(new Consumer());

        // 运行一段时间
        Thread.sleep(3000);

        System.out.println("\n主线程：准备停止生产者和消费者...");
        running = false; // 设置 volatile 标志，让线程在下一次循环检查时退出 (对于未使用阻塞方法的循环有效)

        // 使用 cancel(true) 来中断线程 (主要针对阻塞方法)
        System.out.println("主线程：中断生产者...");
        producerFuture.cancel(true);
        System.out.println("主线程：中断消费者...");
        consumerFuture.cancel(true);

        // 关闭线程池并等待任务结束
        executor.shutdown();
        if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
            System.err.println("ExecutorService 未能在5秒内正常关闭，强制关闭...");
            executor.shutdownNow();
        }

        System.out.println("主线程：生产者和消费者已停止。");
    }
}

在这个例子中：

生产者和消费者的主循环都检查 !Thread.currentThread().isInterrupted()。
它们都使用了可中断的阻塞方法 (queue.put() 和 queue.take())。
main 方法通过调用 future.cancel(true) 来发起中断请求。
catch (InterruptedException e) 块处理中断信号，并准备退出。
我们还使用了一个 volatile boolean running 标志，虽然在这个特定例子中 cancel(true) 更直接，但在某些不依赖阻塞方法中断的场景下，volatile 标志是另一种协作停止的方式。

8. 总结

Java 线程中断是一种强大而优雅的线程协作机制，用于请求线程停止其当前任务。它并非强制终止，而是依赖于目标线程的主动响应。

关键要点回顾：

中断是一种协作机制，不是强制命令。
核心是中断状态位 (boolean) 和三个方法：interrupt() (设置状态/唤醒阻塞), isInterrupted() (检查状态), Thread.interrupted() (检查并清除状态)。
InterruptedException 在可中断阻塞方法被中断时抛出，并且会清除中断状态。
必须正确处理 InterruptedException：恢复状态或向上抛出，不要吞掉。
任务代码需要主动检查中断状态 (isInterrupted()) 或处理 InterruptedException 来响应中断。
注意不可中断的阻塞 (synchronized, 传统 I/O)，并使用替代策略来停止相关线程。
优先使用中断机制实现线程的优雅关闭和取消操作。