知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 44 - 线上线程死锁排查 > 导读:接口超时率飙到 80%,但 CPU 只有 20%——这种"慢而不忙"的组合,往往是被死锁卡住的线程把线程池占满了。本文讲清怎么用 `jstack` 读出错综的锁等待环,以及两种最典型死锁代码的根治法。 ## 一、先建立全局认知 ### Q:接口大面积超时但 CPU 很低,为什么反而要怀疑死锁? A:因为这两者的组合本身就排除了"计算型"故障: ``` 现象: - 接口超时率飙升到 80% - CPU 使用率正常(20%)← 不像是死循环 - 线程池活跃线程数 = 最大线程数(全部被占满) - 任务队列持续增长 ``` 推理链条是:**CPU 不高 → 线程不是在算,而是在等;线程池全满 → 等的是"永远不会到来的东西";队列堆积 → 新任务得不到执行**。这三点合起来,最典型的原因就是线程被永久阻塞(死锁),无法释放回线程池。 对比一下另一种常见故障就能看出差别:如果是死循环,CPU 会打满;如果是下游变慢,线程状态是 `TIMED_WAITING` 且有超时兜底。**只有死锁才会让线程无限期地挂在那里**。 ### Q:完整的排查流程是什么? A:  [编辑 Excalidraw 源图](/images/java-interview-copy/online-troubleshoot/44-online-thread-deadlock-online-thread-deadlock-diagnosis-flow-diagram.excalidraw)  *图:死锁排查:jstack 后按有无死锁分两路* ``` 接口超时 + CPU 正常 + 线程池满 │ ▼ jstack <pid> 导出线程快照 │ ▼ 搜索 "Found deadlock" 或 "BLOCKED" 状态线程 │ ┌────┴────┐ 有死锁 无死锁但大量 BLOCKED │ │ ▼ ▼ 分析加锁顺序 分析锁竞争热点 修复代码 减小锁粒度/换无锁方案 ``` 这个分支很关键:**有死锁**是一条确定性的修复路径;**没有死锁但大量 `BLOCKED`** 则是"锁竞争过于激烈",方向完全不同——不是修代码 bug,而是减小锁粒度或换无锁结构。 ## 二、理解核心机制 ### Q:怎么抓线程快照? A: ```bash # 1. 找到 Java 进程 PID jps -l # 或 ps -ef | grep java # 2. 导出线程快照 jstack <pid> > thread_dump.txt # 3. 如果进程无响应,强制导出 jstack -F <pid> > thread_dump.txt ``` `-F`(force)用于进程已经卡死、普通 `jstack` 无法 attach 的场景。代价是它拿到的是"未经过安全点协商"的快照,可能略有失真——但比起拿不到快照,这仍是值得的选择。 ### Q:`jstack` 输出里的死锁信息怎么读? A:JVM 会**直接把死锁环标出来**,不需要你自己找: ``` Found one Java-level deadlock: ============================= "pool-1-thread-1": waiting to lock monitor 0x00007f8b3c003a18 (object 0x000000076ab4c6d0, a java.lang.Object), which is held by "pool-1-thread-2" "pool-1-thread-2": waiting to lock monitor 0x00007f8b3c005d28 (object 0x000000076ab4c6e0, a java.lang.Object), which is held by "pool-1-thread-1" Java stack information for the threads listed above: =================================================== "pool-1-thread-1": at com.example.TransferService.transfer(TransferService.java:25) - waiting to lock <0x000000076ab4c6d0> (a java.lang.Object) - locked <0x000000076ab4c6e0> (a java.lang.Object) "pool-1-thread-2": at com.example.TransferService.transfer(TransferService.java:25) - waiting to lock <0x000000076ab4c6e0> (a java.lang.Object) - locked <0x000000076ab4c6d0> (a java.lang.Object) Found 1 deadlock. ``` 解读: - `pool-1-thread-1` 持有锁 `0x...c6e0`,等待锁 `0x...c6d0` - `pool-1-thread-2` 持有锁 `0x...c6d0`,等待锁 `0x...c6e0` - 互相等待 → 死锁 **两个线程的栈顶都指向同一行 `TransferService.java:25`**,这本身就是强信号:同一个方法在不同线程里以不同顺序加锁,就是死锁的经典写法。 ## 三、放进真实场景 ### Q:最常见的死锁代码有哪两种模式? A:模式一是**加锁顺序不一致**: ```java // 经典死锁:两个线程以不同顺序获取两把锁 public class TransferService { private final Object lockA = new Object(); private final Object lockB = new Object(); // 线程 1 调用 public void method1() { synchronized (lockA) { // 先锁 A sleep(100); synchronized (lockB) { // 再锁 B → 等待线程 2 释放 B // 业务逻辑 } } } // 线程 2 调用 public void method2() { synchronized (lockB) { // 先锁 B sleep(100); synchronized (lockA) { // 再锁 A → 等待线程 1 释放 A → 死锁! // 业务逻辑 } } } } ``` 模式二更隐蔽——**线程池嵌套提交**,代码里完全看不到 `synchronized`: ```java // 线程池中的任务又向同一个线程池提交任务并等待结果 ExecutorService pool = Executors.newFixedThreadPool(2); pool.submit(() -> { // 任务 A 提交子任务到同一个线程池,并等待结果 Future<String> future = pool.submit(() -> "result"); return future.get(); // 如果线程池满了,子任务排队等线程,父任务等子任务 → 死锁 }); ``` 模式二的本质是**"资源等待环"而不只是"锁等待环"**:父任务占着线程等子任务,子任务排着队等线程,而线程全被父任务占着。这也解释了为什么 `jstack` 可能只显示一堆 `WAITING` 而**没有** `Found deadlock` ——JVM 的死锁检测只覆盖监视器锁和 `Lock`,不覆盖线程池的排队依赖。 ### Q:怎么根治加锁顺序不一致? A:让所有线程按同一顺序申请锁: ```java public class TransferService { // 按账户 ID 排序,保证所有线程加锁顺序一致 public void transfer(Account from, Account to, BigDecimal amount) { Account first = from.getId() < to.getId() ? from : to; Account second = from.getId() < to.getId() ? to : from; synchronized (first) { synchronized (second) { from.deduct(amount); to.add(amount); } } } } ``` **先排序、再按序加锁**,从结构上让循环等待不可能形成。这是最彻底的做法——它不是"降低死锁概率",而是"消除这类死锁"。 ### Q:不想依赖加锁顺序怎么办? A:用带超时的 `tryLock`,把"永久等待"变成"等待一段时间后放弃": ```java public class SafeTransferService { private final Map<Long, ReentrantLock> lockMap = new ConcurrentHashMap<>(); public boolean transfer(Long fromId, Long toId, BigDecimal amount) { ReentrantLock lockFrom = lockMap.computeIfAbsent(fromId, k -> new ReentrantLock()); ReentrantLock lockTo = lockMap.computeIfAbsent(toId, k -> new ReentrantLock()); try { // tryLock 带超时,拿不到锁就放弃,不会死锁 if (lockFrom.tryLock(3, TimeUnit.SECONDS)) { try { if (lockTo.tryLock(3, TimeUnit.SECONDS)) { try { // 执行转账 doTransfer(fromId, toId, amount); return true; } finally { lockTo.unlock(); } } } finally { lockFrom.unlock(); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return false; // 获取锁超时,返回失败 } } ``` 这个方案的核心价值是**把死锁降级为"偶发的失败"**:拿不到锁就在超时后返回失败(由上层重试或提示用户),而不是让线程永久挂住、连带拖垮整个线程池。 > 两个细节:`InterruptedException` 被捕获后必须**重新设置中断标志**(`Thread.currentThread().interrupt()`),否则中断信号会丢失;`tryLock` 的嵌套必须保证任何一条路径上,已获取的锁都会被释放(用双层 `try-finally` 就是为此)。 ### Q:怎么让死锁被自动发现,而不是等接口超时告警? A:用 JVM 自带的 `ThreadMXBean` 做定时检测: ```java // 程序内置死锁检测(可定时执行) public class DeadlockDetector { public static void detect() { ThreadMXBean mxBean = ManagementFactory.getThreadMXBean(); long[] deadlockedThreads = mxBean.findDeadlockedThreads(); if (deadlockedThreads != null) { ThreadInfo[] threadInfos = mxBean.getThreadInfo(deadlockedThreads, true, true); StringBuilder sb = new StringBuilder("检测到死锁!\n"); for (ThreadInfo info : threadInfos) { sb.append(info.getThreadName()) .append(" 持有: ").append(info.getLockName()) .append(" 等待: ").append(info.getLockInfo()) .append("\n"); } // 告警通知 alertService.send(sb.toString()); } } } // 定时检测 @Scheduled(fixedRate = 30000) // 每 30 秒检测一次 public void deadlockCheck() { DeadlockDetector.detect(); } ``` 它用的是与 `jstack` 相同的底层能力,所以能发现的是**同一类死锁**(监视器锁与 `Lock`)。30 秒一次的检测成本极低,但能把发现时机从"用户投诉"提前到"故障发生后的半分钟内"。 ### Q:`jstack` 里大量 `WAITING` 但没死锁,怎么分析? A:看线程在等什么: 1. `WAITING on condition` + `parking` → 可能是线程池空闲等待任务; 2. `WAITING on monitor` → 等待 `wait()/notify()`,检查是否有线程忘记 `notify`; 3. `TIMED_WAITING` + `sleep` → 检查是否有不合理的 `sleep`。 ### Q:怎么避免线程池嵌套导致的死锁? A:1)父任务和子任务用不同的线程池;2)子任务用异步回调(`CompletableFuture`)而不是 `future.get()` 阻塞等待;3)线程池设置合理的拒绝策略和队列大小。 第 2 条是最根本的——**只要有线程在"占着资源等另一个任务",就存在资源等待环**。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A: 1. **排查工具**:`jstack <pid>` 导出线程快照,搜索 `Found deadlock` 关键字,分析互相等待的锁; 2. **常见原因**:加锁顺序不一致、线程池嵌套提交任务并等待结果、数据库行锁死锁; 3. **预防策略**:统一加锁顺序(按 ID 排序)、用 `tryLock` 设置超时避免永久等待、避免在持有锁时调用外部服务; 4. **监控手段**:`ThreadMXBean.findDeadlockedThreads()` 定时检测,发现死锁立即告警。 ### Q:为什么"接口超时 + CPU 正常"比"接口超时 + CPU 打满"更危险? A:CPU 打满时,通常是计算密集型问题,线程仍在推进,服务可能只是"慢";而 CPU 正常却大面积超时,说明线程**卡在等待状态**,线程池一旦被占满就完全无法恢复——**除非重启或改代码,否则不会自愈**。这也是死锁类故障往往需要发版修复的原因。 --- ## 自测 1. 接口超时率 80%、CPU 20%、线程池满,你会先执行哪条命令? 2. `jstack` 里两个线程栈顶都指向同一行代码,为什么这是强信号? 3. 为什么线程池嵌套死锁可能**不会**被 `jstack` 报出 `Found deadlock`?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入