外观
02 - Java 线程生命周期与正确中断方式
适用 JDK:JDK 8+。文中涉及
Thread.stop()的版本变化时会单独说明。
前置阅读:01 - 线程安全到底在保护什么。
摘要
服务开始关闭后,进程为什么迟迟不退出?调用 interrupt() 后,线程为什么还在运行?关键在于:发出关闭请求、唤醒等待中的线程、让任务结束,是三个不同的步骤。本文先解释线程的六种状态,再说明中断如何传递取消请求,以及后台任务怎样配合关闭。
1. 场景引入:应用已经关闭,JVM 却一直不退出
假设一个服务启动后台线程同步数据。下面用持续循环简化这个场景,不包含定时调度逻辑:
java
public class SyncWorker {
public static void main(String[] args) {
Thread worker = new Thread(() -> {
while (true) {
syncData();
}
}, "data-sync-worker");
worker.start();
System.out.println("main method finished");
}
private static void syncData() {
// 模拟持续执行的后台任务
}
}在这个例子中,main 方法结束只表示主线程完成了工作,后台线程仍在执行无限循环。worker 是由主线程创建的用户线程(User Thread,也称非守护线程),它的存活会阻止 JVM 正常退出。用户线程与后文的守护线程,区别在于 JVM 退出时是否需要等待它们结束。
你可能会想到改用守护线程(必须在 start() 之前设置):
java
worker.setDaemon(true); // 改为守护线程或者:
java
worker.interrupt(); // 中断线程但两种做法都不能直接等价于“安全停止任务”:
- 守护线程不保证执行
finally或完成数据刷新; interrupt()通常不会强制终止线程,它只发出一个中断请求。
这里的“协作式中断”指:调用方发出请求,任务在可以安全结束的位置响应,再自行退出。原来的无限循环没有检查中断,因此仅调用 worker.interrupt() 不会让它结束。要设计关闭流程,先要知道线程是正在执行,还是在等待锁或其他事件。
2. Java 线程的六种状态
线程对象创建后,只有调用 start() 才会启动新的执行流程。执行期间,线程可能运行,也可能等待锁、任务或其他线程;当 run() 返回或因未捕获异常结束时,线程才终止。等待结束意味着可以继续执行,并不意味着任务已经完成。
Java 用 Thread.State 枚举描述这六种状态。表中的 Monitor(监视器)是 synchronized 使用的内置锁机制;临界区是受锁保护的代码区域。
| 状态 | 含义 | 常见触发方式 |
|---|---|---|
NEW | 线程对象已创建,尚未启动 | new Thread(...) |
RUNNABLE | 正在执行,或等待 CPU 调度 | 运行 Java 代码、部分 I/O |
BLOCKED | 等待获取 synchronized Monitor | 进入已被其他线程持有的内置锁 |
WAITING | 无期限等待其他线程的特定动作 | Object.wait()、Thread.join()、LockSupport.park() |
TIMED_WAITING | 有最长时间限制的等待 | sleep()、wait(timeout)、join(timeout)、parkNanos() |
TERMINATED | run() 已结束 | 正常返回或抛出未捕获异常 |
下面是常见转换的简图,并未列出所有路径。例如,wait() 被唤醒后还需要重新获取 Monitor;如果锁仍被其他线程持有,线程会先进入 BLOCKED。
图表将在阅读到此处时加载…
2.1 RUNNABLE 不等于正在占用 CPU
Java 将“已就绪等待 CPU”和“正在 CPU 上执行”都归入 RUNNABLE。部分在 Native 层(本地代码层)等待 I/O(输入输出)的线程,在 Java 线程快照(Thread Dump,下文简称 Dump)中也可能显示为 RUNNABLE。
因此,状态回答的是“线程处于哪类执行阶段”,不能单独回答“消耗了多少 CPU”。排查 CPU 问题需要结合线程 CPU 时间、多次 Dump,以及 JFR(Java Flight Recorder,运行事件记录工具)或 async-profiler(性能采样工具)。
2.2 BLOCKED 专指等待 synchronized
BLOCKED 并不是“所有阻塞”的泛称。它在 Java 状态模型中特指:线程正在等待获取某个 Monitor,也就是等待进入 synchronized 临界区。
java
public class BlockedDemo {
private static final Object LOCK = new Object();
public static void main(String[] args) throws Exception {
Thread holder = new Thread(() -> {
synchronized (LOCK) {
sleepSilently(10_000);
}
}, "lock-holder");
Thread competitor = new Thread(() -> {
synchronized (LOCK) {
System.out.println("acquired");
}
}, "lock-competitor");
holder.start();
Thread.sleep(100); // 只用于演示,生产同步不要依赖 sleep
competitor.start();
Thread.sleep(100);
System.out.println(competitor.getState()); // 通常为 BLOCKED
}
private static void sleepSilently(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}示例希望 holder 先持有锁,competitor 再尝试进入同一临界区。holder 在锁内休眠时仍持有锁,因此竞争线程通常会显示为 BLOCKED。不过,两次 sleep(100) 不能保证这个执行顺序,注释是预期现象,不是稳定的测试断言。
ReentrantLock 是需要显式调用获取和释放方法的锁,通常基于 AQS(AbstractQueuedSynchronizer,组织等待线程的同步框架)和 LockSupport.park() 等待。因此,它的等待线程在 Dump 中更常表现为 WAITING 或 TIMED_WAITING,不能按“等待锁”一概判断为 BLOCKED。
2.3 Java 状态不是操作系统状态的一一映射
Thread.State 是 JVM 暴露给 Java 程序的抽象。操作系统可能使用 Running、Runnable、Sleeping 等更细的状态。线上排障时,不要将 Java 的 RUNNABLE 机械地等同于 Linux 的 Running。
3. start() 和 run() 到底有什么区别
java
Thread thread = new Thread(() -> {
System.out.println(Thread.currentThread().getName());
}, "worker");
thread.run(); // 普通方法调用,由当前线程执行
thread.start(); // 启动新线程,新线程再执行 run()run() 只是一个普通 Java 方法。如果在 main 线程中直接调用,任务就在 main 线程中同步执行。
这段代码是局部片段:直接调用 run() 时会输出当前线程名,调用 start() 后,新线程执行时会输出 worker。
start() 会请求 JVM 启动新线程,待新线程获得调度后,再由它调用 run()。它还建立一条 happens-before 关系,即 Java 内存模型规定的可见性与有序性保证,而不是单纯比较时钟上的先后:
调用
Thread.start()之前的操作,happens-before 新线程中的操作。
因此,启动前写入的任务配置可以被新线程看到;这条规则并不自动保证启动后的共享数据修改可见。具体规则在下一篇 JMM 文章中展开。
一个 Thread 对象只能成功调用一次 start()。已经启动或已终止的线程再次调用 start(),会抛出 IllegalThreadStateException。如果需要重复执行任务,应创建新线程,或将任务交给线程池。
4. interrupt() 是请求,不是强制终止
每个 Java 线程都有一个中断标记(Interrupt Status),用来记录中断请求。它不是线程生命周期状态:线程可以带着已设置的中断标记继续运行。调用:
java
worker.interrupt();核心语义是“向 worker 发出中断请求”。线程是否退出,取决于:
- 线程正在执行纯计算代码,还是阻塞在可中断方法上;
- 任务代码是否检查中断标记;
- 捕获
InterruptedException后是退出、向上抛出,还是吞掉异常继续运行。
4.1 两个检查中断的 API
java
boolean interrupted = thread.isInterrupted();isInterrupted() 查询指定线程的中断标记,不会清除标记。
java
boolean interrupted = Thread.interrupted();Thread.interrupted() 是静态方法,检查当前线程,并且会清除已设置的中断标记。
java
Thread.currentThread().interrupt();
System.out.println(Thread.currentThread().isInterrupted()); // true
System.out.println(Thread.interrupted()); // true,并清除
System.out.println(Thread.currentThread().isInterrupted()); // false如果只想查询状态,通常使用 isInterrupted()。使用 Thread.interrupted() 后,后续代码可能读到 false,因为前一次查询已经清除了请求;使用它时应明确由哪一层负责处理这个请求。
5. 不同状态收到中断时会发生什么
5.1 运行中的计算任务
对于没有进入可中断阻塞方法的线程,interrupt() 通常只设置中断标记。如果任务永远不检查,就会继续执行。
java
public class ComputationTask implements Runnable {
@Override
public void run() {
long result = 0;
while (!Thread.currentThread().isInterrupted()) {
result = calculateNext(result);
}
System.out.println("task cancelled, result=" + result);
}
private long calculateNext(long value) {
return value * 31 + 1;
}
}这个示例把循环边界作为响应取消的位置。收到中断后,任务要等当前一次 calculateNext() 返回,才会再次检查标记,所以检查标记不能打断循环体内部的长操作。检查越频繁,通常越容易及时响应,但也会增加检查开销;热点计算可以每处理一批数据检查一次,具体频率应根据取消时延目标和基准测试确定。
5.2 sleep()、wait() 和 join()
sleep() 让当前线程休眠,wait() 等待条件变化,join() 等待目标线程结束。线程阻塞在这些方法时收到中断,方法会抛出 InterruptedException,同时清除中断标记。异常表示等待被中断,不表示线程已经退出。
java
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().isInterrupted()); // false
}下面的 catch 是局部处理片段。如果当前方法不能向上抛出 InterruptedException,通常要恢复标记并返回,把取消请求留给调用方处理;只恢复标记却继续无条件循环,仍不能保证任务结束:
java
catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 保留取消请求
return;
}5.3 LockSupport.park()
park() 在线程被中断时会返回,但不抛出 InterruptedException,也不会自动清除中断标记。调用者需要自己检查返回原因。
java
LockSupport.park();
if (Thread.currentThread().isInterrupted()) {
// 根据任务协议决定是否退出
}park() 还允许无原因返回(Spurious Return,也称虚假返回),即没有预期的唤醒动作也可能返回。因此,“返回了”不等于“等待的条件成立了”。和 wait() 类似,实际代码应在循环中重新检查条件。上面只是局部片段,需导入 java.util.concurrent.locks.LockSupport。
5.4 等待 synchronized Monitor
线程处于 BLOCKED、等待进入 synchronized 时,interrupt() 不会让它立即放弃获取 Monitor。中断标记会被设置,线程仍要等到获得锁后才能继续执行并自行检查。
如果业务需要“等锁时可取消”,可以考虑 ReentrantLock.lockInterruptibly():
java
lock.lockInterruptibly();
try {
// 临界区
} finally {
lock.unlock();
}6. 反例:吞掉 InterruptedException
下面是任务消费循环的局部片段,Task、getQueue() 和 execute() 代表业务代码。BlockingQueue 是阻塞队列;队列为空时,take() 会等待任务到来。
java
public void run() {
while (true) {
try {
BlockingQueue<Task> queue = getQueue();
Task task = queue.take();
task.execute();
} catch (InterruptedException e) {
// 什么都不做
}
}
}问题出在异常后的控制流:take() 抛出异常时已清除标记,空 catch 又让程序回到 while (true),于是线程再次等待任务。这次取消请求既没有促使循环退出,也没有作为标记或异常继续传递。
常见现象是:线程池、容器或应用开始关闭,但某个工作线程始终无法停止。
7. 正例:一个可取消的后台工作线程
关闭协议需要同时表达两件事:是否还接收新任务,以及怎样让等待中的工作线程继续执行关闭逻辑。下面用 accepting 表达第一件事,用 interrupt() 唤醒队列等待,再用 join(timeout) 限时等待退出。
AtomicBoolean 提供可见的状态读写和原子更新;compareAndSet(true, false) 只在当前值为 true 时将它改为 false。队列用于保存尚未执行的任务。下面保留为教学示例,仅作静态审阅,未编译运行;它不提供完整的生产级关闭保证。
java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public class GracefulWorker implements AutoCloseable {
private final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
private final AtomicBoolean accepting = new AtomicBoolean(true);
private final Thread worker;
public GracefulWorker() {
worker = new Thread(this::runLoop, "graceful-worker");
worker.start();
}
public boolean submit(Runnable task) {
if (!accepting.get()) {
return false;
}
return queue.offer(task);
}
private void runLoop() {
try {
// 关闭后继续处理队列中已接收的任务
while (accepting.get() || !queue.isEmpty()) {
Runnable task;
try {
task = queue.poll(500, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
if (accepting.get()) {
// 非关闭流程的中断交给上层感知
Thread.currentThread().interrupt();
break;
}
// close() 发出的中断只用于唤醒 poll(),
// 中断标记已由 InterruptedException 清除,继续排空队列。
continue;
}
if (task == null) {
continue;
}
try {
task.run();
} catch (RuntimeException e) {
// 单个任务失败不应直接终止整个工作线程
System.err.println("task failed: " + e.getMessage());
}
}
} finally {
System.out.println("worker stopped, remaining=" + queue.size());
}
}
@Override
public void close() throws InterruptedException {
if (!accepting.compareAndSet(true, false)) {
return;
}
// 唤醒可能正阻塞在 poll() 上的工作线程
worker.interrupt();
// 最多等待 5 秒,避免关闭无期限卡住
worker.join(5_000);
if (worker.isAlive()) {
System.err.println("worker did not stop within timeout");
}
}
}当 close() 把 accepting 改为 false 后,循环仍会尝试处理队列中的任务。如果中断发生在 poll() 等待期间,异常会清除标记;代码根据关闭状态选择继续排空队列。这是按明确协议处理请求,与第 6 节的空 catch 不同。join(5_000) 限制的是调用方等待的时间,超时日志并不表示工作线程已经停止。
从代码的控制流可以看出以下边界,使用时不能把它理解为“关闭后所有已接收任务都一定完成”:
submit()的状态检查与入队是两个操作。如果提交线程读到true后暂停,工作线程可能先完成关闭并退出,随后提交线程仍入队并返回成功。单个原子变量不保证这组复合操作原子化。- 中断也可能发生在
task.run()中,任务如何响应取决于自己的实现,不能保证它只用于唤醒poll()。 - 再次调用
close()会直接返回,不会再次等待;调用方在join()中被中断时,异常会向上传递,也不能据此判断工作线程已经结束。 - 队列未设置容量上限;消费慢于提交时,积压仍需要单独治理。
生产环境还需要明确:
- 关闭时是处理完队列,还是立即丢弃未开始任务;
- 正在执行的任务是否支持中断;
- 未处理任务是否需要落盘、重试或转移给其他实例;
- 关闭超时后由谁记录告警和执行最终降级。
8. 哪些中断处理方式是合理的
8.1 向上抛出 InterruptedException
InterruptedException 是受检异常,需要在方法签名中声明或捕获。以下示例都是局部片段,队列和业务类型由调用方提供。如果方法签名允许,可以直接向上传递:
java
public Task takeTask() throws InterruptedException {
return queue.take();
}这样上层更了解业务生命周期的代码可以决定退出、重试还是执行补偿。
8.2 恢复中断标记
当接口不允许抛出受检异常时,恢复标记让调用链上层仍能看到中断:
java
try {
queue.take();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}8.3 明确把中断转换为业务取消
在任务执行与业务接口衔接的边界层,可以将中断转换成表示业务取消的异常,但仍建议保留中断状态。下面的 TaskCancelledException 是业务自定义异常,需自行定义:
java
catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new TaskCancelledException("task was interrupted", e);
}不推荐笼统地记一条错误日志后继续运行。中断通常是正常的生命周期信号,不一定是系统故障。
9. 为什么不应该使用 Thread.stop()
在仍支持强制停止的旧版本中,Thread.stop() 可能在目标线程执行到任意位置时强制它停止,并释放它持有的 Monitor。锁释放后,其他线程就可能读到尚未更新完整的数据,破坏业务不变量,也就是操作前后必须维持的规则。
例如,转账代码先扣减转出账户,还没来得及增加转入账户就被强制停止,系统总资金就会被破坏。
Thread.stop() 很早就已被废弃;JDK 20 起,调用该方法会抛出 UnsupportedOperationException。现代 Java 应使用协作式取消:中断、超时、取消标记以及可恢复的任务边界。
10. 守护线程不是优雅关闭方案
通过以下方式可以在启动前将线程设置为守护线程:
java
thread.setDaemon(true);
thread.start();当 JVM 中只剩守护线程时,JVM 可以退出,不会等待这些线程完成。因此守护线程不应承担必须可靠完成的工作,例如:
- 持久化最后一批数据;
- 提交关键事务;
- 释放外部租约或分布式锁;
- 确保消息发送或刷盘成功。
守护线程适合那些“进程活着时有用,进程结束后没有独立价值”的辅助任务,但仍应尽量提供正常的关闭路径。
11. 线上排查:线程为什么停不下来
当应用关闭超时或进程无法退出时,先确定哪个非守护线程仍存活,再检查它在等待什么,最后对照关闭信号和退出日志。下面的命令仅供排查参考。
11.1 查找存活的非守护线程
bash
jcmd <pid> Thread.print
# 或
jstack <pid><pid> 应替换为目标 Java 进程 ID;命令需要环境中有相应 JDK 工具,并具备访问目标进程的权限。Dump 中的调用栈记录线程当前经过的方法,栈顶有助于定位正在执行或等待的位置。重点检查:
- 线程名是否能对应到业务组件;
- 线程是用户线程还是 daemon 线程;
- 当前状态是
RUNNABLE、WAITING还是BLOCKED; - 栈顶停在业务循环、网络 I/O、队列等待还是锁获取上。
11.2 连续采样,不要只看一次 Dump
单次线程 Dump 只是一张瞬时照片。建议间隔数秒采集 3 次或更多,观察栈帧是否变化:
- 始终停在同一把锁上:可能是锁竞争或死锁;
- 始终停在
queue.take():可能没有发送关闭信号; - 栈持续变化但 CPU 很高:可能是忙循环或计算热点;
- 中断后又回到同一阻塞方法:可能吞掉了
InterruptedException。
11.3 检查关闭日志与指标
推荐为长生命周期组件记录:
- 开始关闭的时间;
- 停止接收新任务的时间;
- 剩余队列长度与活跃任务数;
- 发送中断和任务真正退出的时间;
- 关闭超时与未完成任务数。
只有一条“shutdown failed”日志,往往无法回答“卡在哪一阶段”。
11.4 区分“没收到中断”和“收到但无法及时退出”
- 没有观察到中断标记:检查是否中断了错误线程、标记是否已被异常或
Thread.interrupted()清除,以及取消是否传递给实际任务。Future是任务结果与取消操作的句柄,执行器(Executor)负责安排任务执行;句柄的取消与任务实际退出需要分别确认。 - 抛出
InterruptedException后又继续运行:检查 catch 是否吞掉中断或无条件重试。 - 中断标记已设置但栈不变:当前可能位于不响应中断的 Native I/O、长计算或
synchronizedMonitor 等待。 - 任务已退出但进程仍不退出:继续查找其他非 daemon 线程和未关闭的 Executor。
线程池关闭与排队详见 09 - ThreadPoolExecutor 参数与容量设计;高 CPU 线程定位见 14 - Java 进程 CPU 飙高排查。
12. 容易踩的坑
12.1 用共享普通 boolean 作为停止标记
java
private boolean stopped;
while (!stopped) {
doWork();
}这是局部片段。如果没有锁或 volatile,工作线程不一定能观察到其他线程对 stopped 的写入。volatile 可以提供可见性保证,但线程阻塞时没有机会重新读循环条件,所以它无法代替唤醒操作。常见做法是用生命周期标记表达关闭策略,再配合 interrupt() 唤醒可中断等待。
12.2 把中断当作错误后无限重试
中断通常是上层在表达“这个任务不再需要”。捕获中断后立即重试同一个阻塞操作,等于拒绝了取消协议。
12.3 在持有锁时执行不可控的阻塞操作
如果线程在 synchronized 内执行无超时网络请求,不仅它自己难以停止,所有等待同一把锁的线程也会堆积。应尽量把外部 I/O 移出临界区,并为下游设置可控的连接、读取和总超时。
12.4 用 sleep() 猜测线程时序
Thread.sleep(100) 只能表示当前线程至少暂停约 100ms,不能保证其他线程已经执行到某个位置。测试并发时应使用 CountDownLatch、CyclicBarrier 或明确的事件条件建立同步点。
13. 面试快问快答
调用 interrupt() 后,线程会立即停止吗?
通常不会。interrupt() 发出中断请求。计算任务需要主动检查中断标记;部分阻塞方法会通过 InterruptedException 响应中断。
isInterrupted() 和 Thread.interrupted() 的区别是什么?
isInterrupted() 查询目标线程且不清除标记;Thread.interrupted() 查询当前线程且会清除标记。
为什么捕获 InterruptedException 后常要再次 interrupt()?
因为抛出 InterruptedException 时中断标记通常已被清除。当当前层无法向上抛出异常时,恢复标记可以让上层继续感知取消请求。
BLOCKED 和 WAITING 有什么区别?
BLOCKED 专指等待获取 synchronized Monitor;WAITING 是通过 wait()、join()、park() 等方式等待其他事件。
为什么不能用 Thread.stop()?
它可能在任意位置破坏线程的执行,释放锁并暴露不一致状态。JDK 20 起调用会抛出 UnsupportedOperationException。
14. 总结
Java 线程的停止是一次协作,而不是外部对执行流的强制切断。
可带走的三个要点:
RUNNABLE不等于正在使用 CPU,BLOCKED专指等待synchronizedMonitor。interrupt()只是取消请求;任务必须检查标记或正确处理InterruptedException。- 捕获中断后要么退出、要么向上抛出、要么恢复标记,不要无声吞掉。