知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 线程中断与优雅停止 > 导读:本文从"服务要下线或重启,业务线程却 stop 不掉,还留下一堆写了一半的数据"这个具体痛点出发,把 stop()/suspend()/resume() 被废弃的根因、interrupt() 的协作式语义、isInterrupted()/interrupted()/InterruptedException 三者的区别与误用、不可中断阻塞的处理、两阶段终止模式、线程池 shutdown 三部曲逐一讲透,最后给出生产用法与踩坑。适合有 Java 基础、正打算把并发代码写到生产可用的同学。 ## 一、先建立全局认知 ### Q:为什么 Thread.stop()、suspend()、resume() 都被废弃了? A:结论先行——因为它们都是"强制/外部"的线程控制手段:stop() 会在任意一点硬生生终止线程并释放它持有的所有锁,suspend() 会让线程抱着锁睡死过去,两者都会破坏数据一致性,甚至直接制造死锁,所以 Java 从很早就把它们标记为废弃,并在新版本里彻底废掉。 先说 stop()。它的语义是"立刻在目标线程里抛出一个 ThreadDeath 错误,让 run() 从任意一行就地中断",这会带来两个致命问题: 1. **释放所有已持有的 monitor(对象监视器)**:ThreadDeath 沿着调用栈向上传播时,线程持有的每一把 `synchronized` 锁都会被 JVM 在栈展开时自动释放。如果此时对象正处于"半更新"状态——比如转账只扣了 A 账户、还没给 B 账户加钱——其他线程马上就能看到这个"被破坏的对象"(damaged object),并据此继续运算,错误会被放大,而且很难复现。官方 Javadoc 把这种对象直接称为 damaged。 2. **静默终止**:ThreadDeath 不像普通异常那样被打印或上报,线程就这么悄悄死了,你可能很久之后才发现数据不对。 再说 suspend()/resume(),它比 stop() 更隐蔽地危险: - suspend() 暂停线程时**不会释放它已持有的锁**。如果目标线程恰好持有一把保护关键资源的锁,那么在它被 resume() 之前,任何想拿这把锁的线程(包括正准备调用 resume() 的那个线程)都会被卡住,直接死锁。 - suspend()/resume() 天生存在竞态:线程 A 调 suspend() 时,线程 B 可能已经先一步调了 resume(),结果 A 挂起后再也没人来唤醒它。 版本行为(需结合版本确认):stop() 自 JDK 1.2 起被标记为废弃;JDK 18 起标记为"deprecated for removal";JDK 20 起被重新定义为**无条件抛出 UnsupportedOperationException**;另一个更危险的 `Thread.stop(Throwable)` 在 JDK 11 已被移除;`Thread.stop()` 本体在更晚的版本(JDK 26)被彻底移除。suspend()/resume() 同样自早期版本废弃,并在 JDK 20 起改为调用即抛 UnsupportedOperationException。这些差异意味着:**同一段调用 stop() 的代码,在不同 JDK 上表现不一样**,更不该在生产使用。 代码示例(反面教材,仅用于说明问题): ```java // 反面示例:演示 stop() 为什么危险(JDK 20 之前才有"效果",JDK 20+ 直接抛异常) // 这段代码不要在生产中使用,它只是用来暴露问题 public class StopIsEvil { static final int[] balance = {100, 100}; // 两个账户,不变量:总和恒为 200 public static void main(String[] args) throws InterruptedException { Thread transfer = new Thread(() -> { while (true) { synchronized (balance) { balance[0] -= 10; // 扣款 // 假设在这里被 stop() 打断:线程持锁状态被强行释放 balance[1] += 10; // 入账 } } }); transfer.start(); Thread.sleep(50); // transfer.stop(); // ← 绝不能这么干 System.out.println("总额应为 200,被 stop 后可能不再是 200"); } } ``` 关键点:`synchronized (balance)` 保证"扣款 + 入账"要么都做完、要么都不做。一旦线程在中间被 stop()(或抛出任何让锁提前释放的异常),不变量"balance[0] + balance[1] == 200"就会被破坏。预期行为:不 stop 时总和始终是 200;一旦 stop,可能出现 190、200、210 之类的中间值。适用/不适用:这只是反例,生产代码永远不要用它;停止线程请用后面讲的协作式方案。 ### Q:interrupt() 到底做了什么?它能把线程"强杀"吗? A:结论先行——不能。interrupt() 不杀线程,它只是把目标线程的**中断标志位(interrupt status)置为 true**,属于"协作式(cooperative)"通知:要不要退出、什么时候退出,完全由目标线程自己决定。 为什么这么设计?因为 Java 没有安全的外部强杀机制,中断的哲学就是"发信号 + 被中断方配合"。具体分两种情况: 1. **目标线程正阻塞在一个"可中断阻塞点"上**(例如 `Object.wait()`、`Thread.sleep()`、`Thread.join()`、`BlockingQueue.take()`、`Lock.lockInterruptibly()`、`Condition.await()`、`LockSupport.park()` 等),打断它会让这些方法**立即返回或抛异常**: - wait/sleep/join/put/take/await 这类会抛出 `InterruptedException`,并且**在抛出前清除中断标志位**; - `InterruptibleChannel`(NIO 可中断通道)会关闭通道并抛出 `ClosedByInterruptException`,同时保留标志位; - 阻塞在 `Selector.select()` 上的线程会被唤醒并立即返回。 2. **目标线程正在正常运行(没在可中断阻塞点)**,interrupt() 只是把标志位置 true,线程**照跑不误**,直到它自己主动去检查标志位。 一句话:**中断是请求,不是命令**。 ### Q:既然只是置标志,为什么我 sleep 的时候会立刻抛异常? A:结论先行——因为 sleep 这类方法内部会检查标志位:一旦发现自己(或进入阻塞期间被别人)被打上了中断标记,就清除标志并抛出 InterruptedException,把控制权交还给你的代码,让你自己决定怎么收尾。 以 `Thread.sleep` 为例,它的契约是:如果当前线程在睡眠期间被中断,就抛出 InterruptedException 并清除中断状态。所以"抛异常"是这些可中断 API 主动提供的一种**向上传递中断信号**的方式,而不是 JVM 在强杀线程。理解这一点之后就会明白:`InterruptedException` 是一条**受检异常**,编译器强制你处理它,本质是在提醒你"这里有一个停止请求,你得表态"。 ### Q:为什么说"中断(interrupt)"和"阻塞(block)"是两个正交的概念? A:结论先行——中断是"给线程发一个请求停止的信号",阻塞是"线程在等待某件事完成";两者互不隶属,只是"可中断的阻塞"把二者联系了起来:这类阻塞点在被打断时会提前返回。 这个正交视角能解释很多看似矛盾的现象: - 一个线程可以**既没被中断也没阻塞**(正常跑着); - 一个线程可以**被中断但没阻塞**(标志位为 true,仍在跑,直到它自己检查标志位); - 一个线程可以**阻塞但不可中断**(等 `synchronized` 锁、等传统 Socket IO),此时中断只是置位,无法叫醒它; - 只有**可中断的阻塞**(sleep/wait/park/take 等)才能让"中断"直接改变"阻塞"的结果。 理解了这张"四象限",你就不会再纠结"为什么我中断了它还不出来"——先确认它到底卡在哪种阻塞上,再选对应的处理方式。 ## 二、理解核心机制 ### Q:isInterrupted()、interrupted()、InterruptedException 到底差在哪? A:结论先行——三者都在处理同一枚中断标志位,但"读/清"的行为不同:`isInterrupted()` 只读不清;`interrupted()` 是**静态方法**、读的是**当前线程**、读完后**会清除**标志;`InterruptedException` 是"可中断阻塞方法被打断时抛出,且**抛出前已清除**标志",所以你 catch 到它时,标志位通常已经是 false。 | 名称 | 类型 | 作用于哪个线程 | 是否清除标志位 | 典型用途 | |------|------|----------------|----------------|----------| | `t.isInterrupted()` | 实例方法 | 方法接收者 t | 否 | 循环里判断"我还要不要继续干" | | `Thread.interrupted()` | 静态方法 | 当前线程 | **是** | 需要"消费一次"中断信号 | | `InterruptedException` | 受检异常 | 抛出它的线程(当前线程) | **抛出时已清除** | 阻塞方法被打断,交还控制权 | 先用一段代码复现"只置标志、不阻塞"的情形: ```java public class InterruptFlagDemo { public static void main(String[] args) throws InterruptedException { Thread t = new Thread(() -> { System.out.println("初始: " + Thread.currentThread().isInterrupted()); // false // 忙等,主动检查标志位,不进入可中断阻塞点 while (!Thread.currentThread().isInterrupted()) { // 自旋 } System.out.println("被置位后: " + Thread.currentThread().isInterrupted()); // true // 标志位仍在:因为它没进过可中断阻塞点,也没调 interrupted() }); t.start(); Thread.sleep(100); t.interrupt(); // 只置标志位 t.join(); } } ``` 关键点/预期行为:线程一直在 while 里忙等,没有进入 sleep/wait,因此 interrupt() 只是把标志位置 true,循环下一次判断读到 true 后退出。预期输出 `初始: false` 和 `被置位后: true`。适用/不适用:忙等检查标志位是有效的,但忙等本身浪费 CPU,真实场景应配合阻塞或带超时的方法。 再看 `interrupted()` 与 `isInterrupted()` 的差异: ```java public class InterruptedVsIsInterrupted { public static void main(String[] args) { Thread.currentThread().interrupt(); // 给当前线程置位 System.out.println(Thread.interrupted()); // true,且清除了标志 System.out.println(Thread.interrupted()); // false,已无标志可读 Thread.currentThread().interrupt(); // 再置位 System.out.println(Thread.currentThread().isInterrupted()); // true,不清除 System.out.println(Thread.currentThread().isInterrupted()); // true,仍是 true } } ``` 预期输出:`true / false / true / true`。第一次 `Thread.interrupted()` 读到 true 之后标志位就被清掉了,第二次读到 false。这就是**最常见的误用来源**:有人在循环条件里写了 `while (!Thread.interrupted())`,第一次读到 true 后标志被清,后续逻辑可能"误以为没人再要求停止",也可能因为标志被过早清掉而丢失信号。 ### Q:catch 到 InterruptedException 之后,为什么不能"吞掉"? A:结论先行——因为抛出 InterruptedException 时标志位已经被清除,如果你 catch 之后什么都不做(最典型的就是只打一行 `e.printStackTrace()`),中断信号就**彻底消失了**,调用方和上层框架再也感知不到"有人要求停止",线程会继续跑,停止请求石沉大海。 InterruptedException 的语义是"我在阻塞时被打断了,接下来怎么办由你定"。它把"继续执行"与"响应中断"的选择权交给你。常见三种正确处理方式: 1. **能向上传播就向上传播**:在方法签名上声明 `throws InterruptedException`,让调用者处理(推荐,信号不丢失)。 2. **不能传播(如实现 `Runnable.run()` 这类不能抛受检异常的方法)就恢复标志位**:调用 `Thread.currentThread().interrupt();`,相当于"我处理不了,但把信号还给上层"。 3. **确实要终止**:清理资源后 `return` 或 `break` 退出。 ```java // 反面:吞掉中断信号(标志位已被清除,且没有恢复) public void bad() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); // 信号丢失,线程继续跑,停止请求失效 } } // 正面 A:向上抛,交给调用方 public void goodA() throws InterruptedException { Thread.sleep(1000); } // 正面 B:不能抛出时,恢复中断标志位 public void goodB() { try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复标志位,让上层仍能感知 } } ``` 关键点:`Thread.currentThread().interrupt()` 是"恢复",不是"再次打断自己"——它只是把标志位重新置 true,让上层(比如线程池框架)能继续感知。适用/不适用:如果你在 catch 里本来就要退出循环并结束线程,恢复标志位也不会有副作用;但如果后续还有阻塞调用,恢复标志位会让它立刻再次抛异常——这一点要心里有数,否则可能"刚恢复就被再次抛出"而让人困惑。 补充一个高频追问:为什么 `Runnable` 无法声明抛出 InterruptedException?因为 `run()` 的签名里没有 `throws`。所以线程池里的任务一旦捕获到中断,通常只能选择"恢复标志位 + 尽快返回"这条路。 ### Q:打断一个正在 wait() 的线程,和打断一个正在 sleep() 的线程,行为一样吗? A:结论先行——都会抛 `InterruptedException` 并清除中断标志,但 `wait()` 多一个"必须先重新拿到监视器再抛异常"的细节,因此它对外表现为"可能不会立刻抛出"。 - `Thread.sleep` 被中断:清除标志、抛 `InterruptedException`,方法直接返回; - `Object.wait` 被中断:线程被从等待集移出,**必须先重新获得该对象的监视器**,然后才抛出 `InterruptedException`;如果监视器一直被别的线程占着,被中断的线程会在拿到锁之前先"卡一会儿"; - 正因如此,`wait` 必须在 `synchronized` 块里调用,而且唤醒后要用 `while` 循环重新检查条件(而不是 `if`),以应对"被中断、被 notify 但条件仍不满足、以及虚假唤醒"这三种情况。 ```java synchronized (lock) { while (!conditionMet()) { // 用 while 而不是 if try { lock.wait(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复标志位并退出等待 return; } } // 条件满足,安全地使用共享状态 } ``` 关键点:`wait` 的"重新抢锁再抛异常"是它和 `sleep` 最主要的差异。适用/不适用:这是 `wait/notify` 协作模型的通用要求;生产上更推荐用 `Condition` 或 `BlockingQueue` 来减少手写 `wait/notify` 的出错面。 ### Q:在循环任务里,退出条件该怎么写? A:结论先行——用 `while (!Thread.currentThread().isInterrupted())` 作为循环条件,或用 volatile 标志位配合;关键是**不要在循环内部反复用 `Thread.interrupted()`**,也不要在 catch 里把信号悄悄吃掉。 ```java public void loop() { while (!Thread.currentThread().isInterrupted()) { try { doWork(); // 可能耗时 Thread.sleep(100); // 可中断阻塞点:被打断会抛异常 } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复标志位 break; // 跳出循环,去执行清理 } } cleanup(); } ``` 这里用 `isInterrupted()`(不清标志)作条件、catch 里恢复标志位:即使 `sleep` 抛异常时清了标志,我们把它补回来,随后 break 退出。预期行为:收到 interrupt 后最多再走一轮循环即可退出,不会"漏掉"停止请求。 ### Q:自己用 volatile 标志位,和用中断标志位,是一回事吗? A:结论先行——不是。volatile 标志位是你**自己定义**的业务信号,语义由你决定(比如"该退出了""该切库了");中断标志位是 **JVM 内建、挂在 Thread 对象上**的标准信号,所有标准库都按统一约定响应它(抛 InterruptedException、唤醒 park 等)。两者语义不同、通常互补,但不能互相替代。 | 对比项 | volatile 业务标志位 | 中断标志位 | |--------|---------------------|------------| | 谁定义 | 你自己的代码 | JVM / Thread 标准 | | 能否唤醒阻塞中的线程 | 不能,阻塞中的线程看不到标志变化 | 能,可唤醒可中断阻塞点 | | 标准库是否识别 | 不识别 | 识别(wait/sleep/park 等都响应) | | 适合表达 | 业务层"该收工了" | 线程层"有人要求你停" | | 谁来维护 | 需要你保证可见性与清理 | 由 Thread 统一维护 | 为什么两者常一起用:volatile 标志位负责**表达业务意图**,中断标志位负责**叫醒阻塞**。这正是两阶段终止模式要"先置 volatile 标志、再 interrupt"的原因——前者保证逻辑上退出,后者保证阻塞中的线程能被唤醒。单独用 volatile 标志位,遇到 `queue.take()` 这类无限阻塞就会失效;单独用中断标志位,则会把"业务是否允许退出"和"线程是否被要求停止"这两件事混在一起,语义不清。 适用/不适用:如果你能控制所有阻塞点都带超时(例如统一用 `poll(timeout)`、`tryLock(timeout)`),理论上单靠 volatile 标志位也能退出;但只要存在一个无限阻塞点,就必须配 interrupt。 ## 三、不可中断的阻塞怎么停 ### Q:synchronized 等待锁、普通 Socket 的 read() 这类"不可中断"的阻塞,interrupt() 有用吗? A:结论先行——没用。对**不可中断阻塞**,interrupt() 只是把标志置位,线程仍然卡在那里;要让它出来,只能靠"**关闭资源**"或"**换成可中断的替代 API**"。 按阻塞类型逐个说明: - **synchronized 获取锁**:`synchronized` 的阻塞是 JVM 层面的 lock 等待,**不响应 interrupt**。要可中断,改用 `ReentrantLock.lockInterruptibly()`,或者用 `tryLock(timeout)` 带超时获取。 - **传统阻塞式 IO(`java.net.Socket` 的 `InputStream.read()`)**:经典阻塞 IO **不响应 interrupt**,但它是"可关闭"的——从另一个线程调用 `socket.close()`,会让阻塞中的 read() 抛出 `SocketException`(或其子类,如 `SocketException: Socket closed`)而返回。 - **NIO 的 `InterruptibleChannel` / `Selector`**:这类**本来就是可中断的**——`InterruptibleChannel` 被打断时会抛 `ClosedByInterruptException` 并关闭通道;阻塞在 `Selector.select()` 的线程会被 interrupt 唤醒并立即返回。 - **`LockSupport.park()`**:可中断,但**不抛异常**——它在被 interrupt 时直接返回,且**不清除中断标志位**(Javadoc 明确说明 park 可能因 unpark、因中断、或"无理由地"返回,因此必须放在循环里重新检查条件)。 先用代码看"关闭资源才能解阻塞": ```java import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class CloseToInterrupt { private volatile Socket socket; private volatile ServerSocket serverSocket; // 工作线程:阻塞在 read() 上 public void serve() { try (ServerSocket ss = new ServerSocket(0)) { serverSocket = ss; Socket s = ss.accept(); socket = s; InputStream in = s.getInputStream(); byte[] buf = new byte[1024]; int n; while ((n = in.read(buf)) != -1) { // 传统阻塞 IO,不响应 interrupt handle(buf, n); } } catch (IOException e) { // 关闭 socket 会让 read() 抛 SocketException,走到这里 System.out.println("IO 中断退出: " + e.getMessage()); } } // 停止:光 interrupt 没用,必须关掉 socket public void shutdown() { try { if (socket != null) socket.close(); // 让 read() 抛异常返回 if (serverSocket != null) serverSocket.close(); // 让 accept() 返回 } catch (IOException ignore) { // 关闭时的异常忽略即可 } } private void handle(byte[] buf, int n) { /* 业务处理 */ } } ``` 关键点:`socket.close()` 才是"解药",interrupt() 对这类阻塞无效。预期行为:shutdown() 之后,阻塞中的 read()/accept() 立刻抛异常返回,工作线程从 catch 里退出。适用/不适用:适用于传统阻塞 IO;如果你用的是 NIO,直接依赖 `InterruptibleChannel` 的可中断语义更干净,不必手动关 socket。注意 close() 之后 read() 抛的是 IOException,应当按"正常退出"而不是"故障"来处理。 再看 `LockSupport.park()` 的正确用法(循环 + 重检条件): ```java // park 可中断但不抛异常,也不清标志位,必须循环重检 while (!canProceed()) { LockSupport.park(this); // 被 interrupt 会直接返回,标志位仍然保留 } ``` 关键点:`park` 返回后必须重新判断条件,不能假设"返回了就一定满足条件"。适用/不适用:这是给锁和同步器实现者用的底层原语,业务代码通常用不到;业务里优先用现成的 `BlockingQueue`、`Lock.lockInterruptibly()` 等更高层 API。 ### Q:除了关闭资源,还有哪些"可中断"的替代 API 可以配合停止? A:结论先行——`ReentrantLock.lockInterruptibly()`、`ReentrantLock.tryLock(timeout, unit)`、`Future.cancel(true)`,以及所有带超时的阻塞重载,都是把"不可中断的无限等待"换成"可中断/可超时等待"的手段。 - `lockInterruptibly()`:等待锁期间可被 interrupt,抛出 `InterruptedException` 并放弃获取锁;它替换掉的是 `synchronized` 那种不可中断的等待。 - `tryLock(timeout, unit)`:带超时尝试获取锁,超时返回 false 而不是无限等;它让线程能周期性回到循环里检查停止标志,适合"既要避免死等、又想批量处理"的场景。 - `Future.cancel(true)`:向正在执行的任务线程发送中断(`mayInterruptIfRunning=true` 时),是线程池层面"取消单个任务"的标准手段;它能否真正停下,仍取决于任务是否响应中断。 - 各类 `BlockingQueue` 的 `put/poll` 超时重载、`Condition.await(timeout, unit)`、`CountDownLatch.await(timeout, unit)` 等:把无限等待改成有限等待,天然为停止留出检查点。 ```java // 用带超时的 tryLock 让等待锁的过程"可检查、可退出" while (running) { if (lock.tryLock(200, TimeUnit.MILLISECONDS)) { try { doWork(); } finally { lock.unlock(); } } // 没拿到锁也没关系:回到循环顶部检查 running / 中断标志 } ``` 关键点:把"无限等待"拆成"有限等待 + 循环重检",是让不可中断场景也能优雅停止的通用改写手法。适用/不适用:`tryLock` 会引入轮询开销和"拿不到锁也要继续转"的逻辑复杂度,只在确实需要可中断/可超时时才用;能接受不可中断等待的地方,`synchronized` 更简单。 ## 四、两阶段终止与线程池优雅停机 ### Q:什么是两阶段终止(Two-Phase Termination)模式? A:结论先行——它是"优雅停止线程"的标准套路:**第一阶段**设置一个可见的停止标志(通常用 `volatile boolean`)请求线程收工;**第二阶段**调用 `interrupt()` 去唤醒**正阻塞在可中断方法上**的线程;最后等线程真正结束并执行清理。 为什么需要两个阶段? - 只有标志位:线程若正阻塞在 `queue.take()` 上,根本不会回到循环去检查标志,会一直卡着。 - 只有 interrupt:能打断阻塞,但语义偏"硬",而且有些代码路径可能把标志清掉。用标志位表达"业务上该收工了",interrupt 只负责"叫醒它",职责更清晰。 完整可运行示例: ```java import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; public class TwoPhaseTerminationDemo { static class Worker implements Runnable { private final BlockingQueue<String> queue = new LinkedBlockingQueue<>(); private volatile boolean running = true; // 第一阶段:可见的停止标志 public void submit(String task) { queue.offer(task); } // 第一阶段:请求停止 public void shutdown() { running = false; } @Override public void run() { try { while (running && !Thread.currentThread().isInterrupted()) { // 带超时的 take:既能周期性响应标志位,又能被 interrupt 唤醒 String task = queue.poll(500, TimeUnit.MILLISECONDS); if (task != null) { doWork(task); } } } catch (InterruptedException e) { // 第二阶段被 interrupt 唤醒:恢复标志位后退出 Thread.currentThread().interrupt(); } finally { cleanup(); // 无论怎么退出,都保证收尾 } } private void doWork(String task) { System.out.println(Thread.currentThread().getName() + " 处理: " + task); } private void cleanup() { System.out.println(Thread.currentThread().getName() + " 清理资源,线程退出"); } } public static void main(String[] args) throws InterruptedException { Worker worker = new Worker(); Thread t = new Thread(worker, "worker-1"); t.start(); worker.submit("A"); worker.submit("B"); Thread.sleep(300); // 让它先干一会儿 worker.shutdown(); // 阶段一:置标志位 t.interrupt(); // 阶段二:叫醒可能正阻塞的线程 t.join(); // 确认它真的退出了 System.out.println("worker 存活? " + t.isAlive()); // false } } ``` 关键点与预期行为: - `queue.poll(500, TimeUnit.MILLISECONDS)` 是"带超时的可中断阻塞",它让线程既能周期性回到循环检查 `running`,又能被 interrupt 立即唤醒,比无限阻塞的 `take()` 更利于优雅收尾。 - 顺序很重要:先 `shutdown()` 置标志,再 `interrupt()` 兜底。这样即便线程此刻没在阻塞,标志位也保证它下一轮退出;若正在阻塞,interrupt 立即唤醒。 - `finally` 里的 cleanup 保证无论正常退出还是被中断都会执行。 ### Q:线程池的 shutdown()、shutdownNow()、awaitTermination() 有什么区别? A:结论先行——`shutdown()` 是"温和收工":不再接收新任务,但**把已提交(队列里)的任务执行完**;`shutdownNow()` 是"拔电源":不再接收新任务、**中断正在执行的线程**、**清空队列**,并把没来得及跑的任务**作为 List 返回**;`awaitTermination(timeout, unit)` 本身不触发停机,它只是**阻塞等待**线程池真正进入 TERMINATED,常和上面两个配合,用来确认"到底停干净没有"。 | 方法 | 是否接收新任务 | 已入队任务 | 正在执行的任务 | 返回值 | 典型用途 | |------|----------------|-----------|----------------|--------|----------| | `shutdown()` | 否 | **继续执行完** | 不打断,跑完 | void | 优雅停机首选 | | `shutdownNow()` | 否 | **清空** | **尝试 interrupt** | `List<Runnable>`(未执行的任务) | 超时兜底、强制下线 | | `awaitTermination(t,u)` | 不影响 | 不影响 | 不打断 | boolean(是否已终止) | 等待/确认收尾 | 一个容易搞错的点:`shutdownNow()` 的"中断"只对**响应中断**的任务有效。如果任务里有 `while(true)` 忙等且从不检查标志位,或阻塞在不可中断的 IO 上,`shutdownNow()` 也**停不掉**它——这正好呼应上一节。 优雅停机流程(推荐顺序): ```java import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class GracefulShutdownDemo { public static void main(String[] args) throws InterruptedException { ExecutorService pool = Executors.newFixedThreadPool(4); for (int i = 0; i < 8; i++) { int id = i; pool.submit(() -> { try { System.out.println("任务 " + id + " 开始"); Thread.sleep(200); System.out.println("任务 " + id + " 完成"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 保留中断信号 System.out.println("任务 " + id + " 被中断"); } }); } // 第一步:拒绝新任务,把队列里的任务跑完 pool.shutdown(); // 第二步:限时等待 if (!pool.awaitTermination(2, TimeUnit.SECONDS)) { // 第三步:还没停干净,强制收尾 List<Runnable> dropped = pool.shutdownNow(); System.out.println("仍有任务未处理,被丢弃: " + dropped.size()); // 第四步:再给一次机会等待 if (!pool.awaitTermination(2, TimeUnit.SECONDS)) { System.out.println("线程池未能完全终止"); } } System.out.println("已终止? " + pool.isTerminated()); } } ``` 关键点:`shutdown()` → `awaitTermination()` → 超时 `shutdownNow()` → 再 `awaitTermination()`,是教科书式的"优雅停机四步"。另外要分清 `isShutdown()`(已停止接收新任务)与 `isTerminated()`(所有任务都已结束)——前者不代表后者。适用/不适用:这套流程适用于你自己管理的 `ExecutorService`;对于 Spring 等框架托管的线程池,通常由框架在其生命周期回调里执行类似逻辑,你不必重复造轮子。 ### Q:生产上优雅停机一般怎么做? A:结论先行——对外先"摘流量",对内再"停线程池";并把停机逻辑注册到 JVM 的关闭钩子(Shutdown Hook)里,保证收到停止信号(如 SIGTERM)时能有序收尾。 大致顺序: 1. **摘流量**:从注册中心下线、停止接收新请求(此处仅作简述,具体取决于你的服务框架与注册中心实现)。 2. **等在途请求处理完**:配合框架的优雅停机能力,给它一个超时窗口。 3. **停业务线程池**:`shutdown()` → `awaitTermination(timeout)` → 超时则 `shutdownNow()`。 4. **关闭资源**:连接池、临时文件、channel 等。 5. **兜底**:用 `Runtime.getRuntime().addShutdownHook(...)` 注册钩子,确保 SIGTERM/正常退出时执行上述流程。 ```java Runtime.getRuntime().addShutdownHook(new Thread(() -> { System.out.println("收到停机信号,开始优雅停机"); // 1. 摘流量(调用注册中心下线接口,此处省略) // 2. 停止线程池 pool.shutdown(); try { if (!pool.awaitTermination(30, TimeUnit.SECONDS)) { pool.shutdownNow(); } } catch (InterruptedException e) { pool.shutdownNow(); Thread.currentThread().interrupt(); } }, "shutdown-hook")); ``` 注意事项:关闭钩子里不要做耗时不可控的操作,也不要依赖其他同样注册了钩子的组件(钩子执行顺序不保证);凡是能设置超时的地方一定给超时。适用/不适用:钩子适合做"进程退出前的最后兜底",但真正的高可用停机(比如先摘流量再终止实例)应尽量由应用外的发布/编排流程驱动,钩子只保证进程退出前尽力清理。 ### Q:优雅停机的顺序和超时预算,有哪些容易踩的坑? A:结论先行——顺序上要"先摘流量、再停线程池、最后关资源",超时上要"由外到内逐层收紧、总时长可控",否则容易出现"线程池还没停完,进程就被强杀"或"请求还在进来,资源已经关了"。 - **先摘流量再停机**:如果还没停止接收请求就关闭线程池,新请求会因为拿不到线程而快速失败;反过来先摘流量、再等在途请求跑完,用户体验更平滑。 - **超时预算**:`awaitTermination` 的超时必须小于"发布平台给进程的优雅停机窗口"(比如平台给 30s,内部就要留出更小的预算并在超时后 `shutdownNow()`),否则进程会在收尾中途被强制杀掉,等于没优雅。 - **幂等与补偿**:停机期间被 `shutdownNow()` 打断的任务可能"做了一半",因此任务本身要尽量幂等,或依赖事务/补偿;对可重试的任务,把未执行的 `List<Runnable>` 记录下来,便于排查与补偿。 - **资源共享要小心**:如果多个线程池共享同一个外部资源(连接池、文件句柄),要确保"最后一个使用者退出后"再关闭它,否则先停的线程池会把别人还要用的资源也关掉。 关键点:优雅停机是一套**有顺序、有预算、可观测**的流程,不是简单调一个 shutdown()。适用/不适用:单机小工具可以简化处理,但只要进程需要承接线上流量,就应按上面的顺序配置并做超时兜底。 ## 小结 - stop()/suspend()/resume() 被废弃的根因是"强制 + 破坏一致性/易死锁",新版本里 stop() 已改为抛 UnsupportedOperationException 甚至被移除。 - interrupt() 是**协作式**的:只置中断标志位;阻塞在可中断方法上会抛 InterruptedException(并清标志),否则线程照跑,需要自己检查标志。 - `isInterrupted()` 只读不清;静态的 `interrupted()` 读当前线程并清除;抛出的 InterruptedException 会把标志位清掉——所以 catch 之后要么向上抛,要么 `Thread.currentThread().interrupt()` 恢复。 - 不可中断阻塞(synchronized 等锁、传统 Socket IO)只能靠"关资源 / 换可中断 API"解决;`LockSupport.park` 可中断但不抛异常也不清标志,必须循环重检。 - 优雅停止用**两阶段终止**:volatile 标志位请示 + interrupt 唤醒兜底;线程池用 **shutdown → awaitTermination → shutdownNow** 的组合,并用关闭钩子保证进程退出前的收尾。 ## 思考题 1. 一个线程正阻塞在 `synchronized` 上等锁,另一个线程对它调 `interrupt()`,会发生什么?如果换成 `ReentrantLock.lockInterruptibly()` 呢? 2. 下面这段代码有什么问题:`while (true) { try { Thread.sleep(1000); } catch (InterruptedException e) { } }`? 3. 为什么 `shutdownNow()` 也不能保证一定停掉所有任务?举一个它无能为力的场景。 4. 在 `catch (InterruptedException e)` 里既打了日志、又调用了 `Thread.currentThread().interrupt()`,随后循环会不会立刻退出?为什么?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入