Java 的线程中断机制是什么？为什么不能用 stop() 停止线程？如何优雅地停止线程？
简化版
Java 没有「强制停止线程」的安全方法——Thread.stop() 已废弃（它会强行终止线程、不释放锁、导致数据不一致）。正确的方式是「中断（interrupt）机制」——它不是「强制停止」，而是「给线程发一个『请求停止』的信号（设置中断标志位）」，线程自己检查这个标志、决定何时停止（协作式）。核心三个方法：interrupt()（给目标线程设置中断标志，「请你停一下」）、isInterrupted()（查询中断标志，「有没有被请求停止」）、Thread.interrupted()（查询并清除中断标志，静态方法）。优雅停止线程的做法：在线程的循环里检查 isInterrupted()（或响应 InterruptedException），收到中断就清理资源、退出。关键：中断是「协作式」的——发起方请求、线程方响应，线程有权决定怎么停（不是被强制杀死）。
详细版
为什么 stop() 被废弃：
Thread.stop() 的问题（已废弃）：
它会"强行"立即终止线程——不管线程在干什么，直接杀掉
① 不释放锁：线程持有的锁不会释放 → 其他线程永久阻塞（死锁）
② 数据不一致：线程可能执行到一半（如改了一半的共享数据）就被杀 → 状态损坏
③ 无法清理资源：来不及关闭文件、连接等
→ 太危险，已废弃，绝不能用中断机制的三个方法：
| 方法 | 作用 | 是否清除标志 |
|---|---|---|
thread.interrupt() | 给 thread 设置中断标志（请求它停止） | — |
thread.isInterrupted() | 查询 thread 的中断标志 | 否（只查询） |
Thread.interrupted() | 查询并清除当前线程的中断标志（静态） | 是（查完清除） |
优雅停止线程的两种情况：
// 情况1：线程在做"正常计算"（没有阻塞）→ 循环里检查中断标志
Thread worker = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) { // 检查中断标志
doWork();
}
cleanup(); // 收到中断，清理资源后退出
});
worker.start();
worker.interrupt(); // 请求停止
// 情况2：线程在"阻塞"（sleep/wait/join/阻塞IO）→ 会抛 InterruptedException
Thread worker2 = new Thread(() -> {
try {
while (true) {
doWork();
Thread.sleep(1000); // 阻塞中被 interrupt → 抛 InterruptedException
}
} catch (InterruptedException e) {
// 收到中断，清理后退出（注意：抛异常时中断标志被清除了）
cleanup();
}
});
worker2.start();
worker2.interrupt();⚠️ 一个关键细节：当线程在阻塞方法（sleep/wait/join）中被中断时，会抛出
InterruptedException，同时「清除中断标志」（标志变回 false）。所以在 catch InterruptedException 时，如果你还想让上层知道「发生过中断」，要重新设置中断标志（Thread.currentThread().interrupt()）——否则上层检查 isInterrupted 会是 false、以为没被中断。这是「catch 到 InterruptedException 别吞掉、要么继续抛、要么恢复中断标志」的原因。
完整版教学
一、为什么不能强制停止线程
Java 设计上「没有安全的强制停止线程的方法」——Thread.stop() 被废弃，suspend()/resume() 也被废弃，原因是「强制停止太危险」：
强制停止（如 stop()）的危险：
线程正在执行时被"强行杀掉"，会导致：
① 锁不释放：线程持有锁时被杀，锁永远不释放 → 其他线程死锁
② 数据不一致：线程改共享数据改到一半被杀 → 数据处于损坏的中间状态
（如转账：扣了 A 的钱、还没加 B 的钱就被杀 → 钱凭空消失）
③ 资源泄漏：来不及关闭文件、连接、清理临时数据
根本问题：外部无法知道"线程现在能不能安全地停"
→ 只有线程自己知道"我现在执行到哪、能不能停"
→ 所以停止线程应该"让线程自己决定何时停"，而不是外部强制杀核心思想：「线程能不能安全停止，只有线程自己知道」——外部强行杀死线程，无法保证「杀在一个安全的时机」（可能正持有锁、正改数据）。所以 Java 的设计是「外部只『请求』停止，线程自己在『安全的时机』响应」——这就是「协作式中断」而非「强制停止」。理解「强制停止危险（不释放锁/数据不一致/资源泄漏）、只有线程自己知道何时能安全停、所以用协作式中断」，就理解了 Java 为什么废弃 stop()、为什么用中断机制。
二、中断机制：协作式的停止请求
Java 的「中断（interrupt）」不是「停止线程」，而是「给线程发一个『请求停止』的信号」——线程收到后自己决定怎么处理：
中断的本质：
每个线程有一个"中断标志位"（一个 boolean）
interrupt() 只是"把这个标志位设为 true"（发出"请你停一下"的请求）
→ 它不会真的停止线程！只是设了个标志
线程怎么响应：
线程自己"检查这个标志"（isInterrupted），决定何时停止
→ 线程有权：立即停、做完当前工作再停、甚至忽略（不推荐）
→ 这是"协作式"——发起方请求、线程方响应，线程有决定权关键认知：interrupt() 只是「设置中断标志」，不会强制停止线程——它是「请求」不是「命令」。线程通过「检查中断标志」来响应这个请求，自己决定「在哪个安全的时机停止」（做完当前事务、释放锁、清理资源后再退出）。这就是「协作式中断」——外部礼貌地请求、线程负责任地响应，保证了「停在安全的时机」。理解「中断是设置标志位发出停止请求、线程自己检查标志决定何时停、协作式而非强制」，就抓住了中断机制的本质——它的核心是「协作」。
三、三个中断方法的区别
中断相关有三个方法，容易混（尤其后两个）：
interrupt()（实例方法）：
thread.interrupt() → 给 thread 设置中断标志（请求 thread 停止）
注意：是"设置标志"，不是停止
isInterrupted()（实例方法）：
thread.isInterrupted() → 查询 thread 的中断标志（true=被请求中断了）
只查询，不清除标志
interrupted()（静态方法）：
Thread.interrupted() → 查询"当前线程"的中断标志，并"清除"它（设回 false）
查询 + 清除，且只针对当前线程三个方法的区别（高频易混）：① interrupt()——设置标志（请求中断）；② isInterrupted()——只查询标志（不清除）；③ Thread.interrupted()——查询并清除标志（静态，只针对当前线程）。最容易混的是 isInterrupted()（查不清除）和 interrupted()（查完清除）——「有 ed 的静态方法会清除」。interrupted() 清除标志的设计是为了「响应中断后复位」（我处理了这次中断请求，把标志清掉）。理解「interrupt 设置标志、isInterrupted 查不清除、interrupted 查完清除（静态）」，就分清了这三个方法——这是中断机制的常考细节。
四、响应中断的两种情况
线程「响应中断」分两种情况，取决于线程当时在做什么：
情况1：线程在"运行"（正常计算，没阻塞）：
中断标志被设为 true，但线程不会自动停
→ 线程要"主动检查" isInterrupted()，发现被中断就退出
while (!Thread.currentThread().isInterrupted()) { doWork(); }
情况2：线程在"阻塞"（sleep/wait/join/可中断的阻塞IO）：
这些阻塞方法能"响应中断"——被 interrupt 时，立即抛出 InterruptedException
且抛异常时会"清除中断标志"
→ 线程在 catch InterruptedException 里处理停止
try { Thread.sleep(1000); } catch (InterruptedException e) { /* 停止 */ }两种情况：① 运行中（非阻塞）——中断只设标志，线程要主动检查 isInterrupted() 才知道被中断（如循环里检查）；② 阻塞中（sleep/wait/join）——这些方法能响应中断、抛 InterruptedException（被 interrupt 时立即从阻塞中醒来抛异常）。所以「优雅停止」要同时处理这两种：循环里检查中断标志（应对运行中）+ catch InterruptedException（应对阻塞中）。理解「运行中要主动检查 isInterrupted、阻塞中会抛 InterruptedException、优雅停止两者都要处理」，就掌握了响应中断的完整方式。
五、InterruptedException 的处理：别吞掉
处理 InterruptedException 有个重要原则——别「吞掉」它（catch 后什么都不做）：
// ✗ 错误：吞掉 InterruptedException（中断信息丢失）
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// 什么都不做 → 中断标志被清除了、上层也不知道发生过中断 → 中断信号丢失
}
// ✓ 正确1：继续往上抛（让上层处理）
void doWork() throws InterruptedException {
Thread.sleep(1000); // 直接抛给上层
}
// ✓ 正确2：恢复中断标志（如果不能抛，就重新设置标志让上层知道）
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // ★ 恢复中断标志
// 然后做清理/退出
}关键原则：catch 到 InterruptedException 后，别「吞掉」它——因为抛 InterruptedException 时中断标志被清除了，如果你 catch 后什么都不做，「发生过中断」这个信息就丢失了（上层检查 isInterrupted 会是 false）。正确做法：① 继续往上抛（throws InterruptedException，让上层决定怎么处理）；② 或恢复中断标志（Thread.currentThread().interrupt()，重新设置标志，让上层能感知到中断）。这样中断信号才不会丢失。这和「异常别吞掉」是同一个道理。理解「InterruptedException 别吞（抛异常时标志被清除）、要么继续抛要么恢复中断标志」，就掌握了处理中断异常的正确方式——这是高频的最佳实践。
六、优雅停止线程的完整实践
把前面的知识综合，优雅停止线程的完整实践：
class Worker implements Runnable {
public void run() {
try {
// 循环里同时应对"运行中"和"阻塞中"两种中断
while (!Thread.currentThread().isInterrupted()) { // 运行中：检查中断标志
doWork();
Thread.sleep(1000); // 阻塞中：会抛 InterruptedException
}
} catch (InterruptedException e) {
// 阻塞时被中断 → 恢复标志（可选）+ 走到 finally 清理
Thread.currentThread().interrupt();
} finally {
cleanup(); // 无论如何都清理资源（关连接、释放锁等）
}
}
}
// 停止：
Thread t = new Thread(new Worker());
t.start();
t.interrupt(); // 请求停止（不是强制杀）优雅停止的要点：① 循环条件检查 isInterrupted()（应对运行中的中断）；② 阻塞方法 catch InterruptedException（应对阻塞中的中断）；③ finally 里清理资源（保证释放锁、关闭连接）；④ 别用 stop()（用 interrupt 请求、线程自己安全退出）。这套做法保证了「线程在安全的时机停止、正确清理资源、不丢中断信号」。而线程池的 shutdownNow() 内部就是用 interrupt() 中断工作线程（所以任务要响应中断才能被 shutdownNow 停下）。理解「优雅停止=检查 isInterrupted+catch InterruptedException+finally 清理+用 interrupt 不用 stop」，就掌握了停止线程的正确姿势——这也和前面「线程池 shutdownNow」串起来了。
记忆钩子：「Java 没有安全的强制停止（stop() 废弃——不释放锁/数据不一致/资源泄漏）；用中断机制（协作式）：interrupt() 只设中断标志（请求停止不强制）、isInterrupted() 查不清除、Thread.interrupted() 查完清除（静态）；响应中断两种：运行中要主动检查 isInterrupted、阻塞中（sleep/wait/join）会抛 InterruptedException（抛时清除标志）；InterruptedException 别吞（要么继续抛要么恢复中断标志）；优雅停止=循环检查 isInterrupted+catch InterruptedException+finally 清理+用 interrupt；shutdownNow 内部用 interrupt」。
七、常见误区与追问
- 误区：interrupt() 会立即停止线程。 interrupt() 只是设置中断标志（发出停止请求），不会强制停止线程；线程要自己检查标志（isInterrupted）或响应 InterruptedException 才会停，是协作式的。
- 误区：可以用 Thread.stop() 停止线程。 stop() 已废弃——它强行杀死线程、不释放锁（导致死锁）、数据不一致、资源泄漏，绝不能用；用 interrupt 协作式停止。
- 误区：isInterrupted() 和 interrupted() 一样。 isInterrupted()（实例方法）只查询不清除标志；Thread.interrupted()（静态方法）查询并清除当前线程的标志；「有 ed 的静态方法会清除」。
- 误区：catch InterruptedException 后什么都不做没关系。 会丢失中断信号——抛 InterruptedException 时标志被清除了，吞掉后上层不知道发生过中断；要么继续抛、要么恢复中断标志（Thread.currentThread().interrupt()）。
- 追问：为什么 Thread.stop() 被废弃？ 它强行立即终止线程——不释放持有的锁（导致其他线程死锁）、可能在修改共享数据到一半时被杀（数据不一致）、来不及清理资源（泄漏）；太危险，改用协作式的中断机制。
- 追问：怎么优雅地停止一个线程？ 用 interrupt() 请求停止（不用 stop）；线程在循环里检查 isInterrupted()（应对运行中）、在阻塞方法 catch InterruptedException（应对阻塞中）、finally 里清理资源，在安全的时机退出。
- 追问：线程在 sleep 时被中断会怎样？ sleep（以及 wait/join）会响应中断——被 interrupt 时立即从阻塞中醒来、抛出 InterruptedException，同时清除中断标志；所以要在 catch 里处理停止逻辑，且注意标志已被清除（需要的话恢复它）。
八、加强记忆
Java 没有安全的「强制停止线程」方法——Thread.stop() 已废弃（强行杀死线程会不释放锁（死锁）、数据不一致、资源泄漏，因为「只有线程自己知道何时能安全停」）。正确方式是「中断（interrupt）机制」——协作式：interrupt() 只是「设置中断标志位（发出『请求停止』的信号）」，不会强制停止线程；线程自己检查标志、在安全时机响应。三个方法：interrupt()（设标志请求中断）、isInterrupted()（查不清除）、Thread.interrupted()（查完清除、静态、只针对当前线程）。响应中断分两种：① 运行中（非阻塞）——要主动检查 isInterrupted()；② 阻塞中（sleep/wait/join）——会抛 InterruptedException（抛时清除中断标志）。处理 InterruptedException 别吞掉（会丢失中断信号）——要么继续往上抛、要么恢复中断标志（Thread.currentThread().interrupt()）。优雅停止线程 = 循环检查 isInterrupted() + catch InterruptedException + finally 清理资源 + 用 interrupt()（不用 stop）。线程池的 shutdownNow() 内部就用 interrupt() 中断工作线程。一句话「stop() 废弃因不释放锁/数据不一致、用协作式中断（interrupt 只设标志不强制停）、运行中查 isInterrupted 阻塞中抛 InterruptedException、异常别吞要恢复标志、优雅停止用 interrupt+检查标志+清理」。