Appearance
2.4-10 死锁:条件、jstack 定位、预防
所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.3-11、2.3-12、2.4-2、2.4-3、2.4-4、2.4-6、2.4-13、4.1-10
题型:原理 / 排查 / 场景
一句话结论:死锁是一组线程互相持有对方需要的锁并永久等待,必须同时满足互斥、持有并等待、不可剥夺、循环等待四个条件,破坏任意一个就能预防;Java 层最可靠的手段是全局锁顺序 + 带超时的
tryLock+ 缩小临界区。定位先用jstack -l或jcmd Thread.print -l找Found one Java-level deadlock和waiting to lock / locked环,再用ThreadMXBean.findDeadlockedThreads()做程序化检测;注意区分死锁、锁竞争、活锁、饥饿和线程池耗尽——它们在线程栈上长得很像,处理方式完全不同。分层要点:
- 死锁的定义与四个必要条件:两个或多个线程各自持有资源、又等待对方持有的资源,形成环,谁也无法推进。四个条件缺一不可:互斥(资源一次只能一个线程用)、持有并等待(拿着一个再要另一个)、不可剥夺(不能强行抢走)、循环等待(等待关系成环)。预防就是破坏其中任意一个,工程上最常用的是破坏循环等待(全局锁顺序)和不可剥夺(超时/可中断)。
- Java 层常见死锁形态:
synchronized嵌套锁顺序相反(monitor 死锁);ReentrantLock交叉加锁;ReentrantReadWriteLock读锁升级写锁(自己等自己释放读锁);StampedLock不可重入导致自死锁;持锁调用回调/外部服务,回调又反向加锁;线程池里父子任务互相等待(同池嵌套、Future.get等自己);数据库事务交叉更新(4.1-10);分布式锁顺序不一致或锁超时导致互相等待。 - 定位第一步:线程栈:
jstack -l <pid>或jcmd <pid> Thread.print -l,重点看三处:Found one Java-level deadlock:段落(JVM 直接给出等待环)、BLOCKED (on object monitor)+waiting to lock <0x...>、以及另一个线程的locked <0x...>。-l还会输出Locked ownable synchronizers,覆盖ReentrantLock等 AQS 锁;不加-l可能看不到java.util.concurrent锁的持有关系。 - 定位第二步:程序化与工具:
ThreadMXBean.findDeadlockedThreads()/findMonitorDeadlockedThreads()返回死锁线程 id,getThreadInfo(ids, true, true)拿到锁信息,可接到健康检查/告警;jconsole/VisualVM有 “Detect Deadlock” 按钮;arthas thread -b直接找阻塞别人的线程;JFR 的jdk.JavaMonitorEnter/jdk.ThreadPark事件可做事后分析。容器里没有 jstack 时可以用kill -3 <pid>把线程栈打到标准输出。 - 区分死锁与“像死锁”的现象:死锁是稳定的环,多次 dump 线程状态和栈不变;锁竞争是
BLOCKED但持有者在跑,过一会儿会推进;活锁是线程都RUNNABLE却一直重试/回滚,没有进展;饥饿是某些线程长期拿不到锁(非公平锁、优先级、长临界区);线程池耗尽是线程都停在WAITING/TIMED_WAITING等队列或Future.get,但等待对象不是锁环。排查时至少连续抓 2–3 次 dump,间隔几秒,比较栈是否固定。 - 预防:工程手段:全局锁顺序(按业务 id/类型排序后加锁,所有路径一致);带超时的
tryLock(失败就释放已持有的锁、退避重试),lockInterruptibly支持中断;一次性获取全部锁或“全拿或全放”;缩小临界区,持锁期间不做 IO/RPC/回调(open call);减少嵌套锁,能用一把锁或并发容器就不用多把;线程池隔离,避免父任务在同池里等子任务;数据库事务短、按固定顺序访问、加索引缩小锁范围、死锁后重试(4.1-10)。 - 恢复流程:先取证(多次线程 dump、
top -Hp、GC/监控),再止血(摘流量、重启实例、回滚变更),最后定位锁顺序并修复;不要只重启不复盘,否则下次还会发生。线上可以用jstack输出里的锁地址在两次 dump 间对比,确认环是否稳定;修复后用压测/混沌注入验证锁顺序和超时路径。 - 边界与取舍:
synchronized无法超时、不可中断,死锁只能靠顺序预防;ReentrantLock.tryLock(timeout)能打破不可剥夺,但引入重试与活锁风险;StampedLock性能好但不可重入、不支持 Condition;读写锁只支持写→读降级,读→写升级必死锁;分布式锁的“死锁”更多是 TTL/续期/顺序问题,要靠唯一 value、看门狗、fencing token 和幂等重试解决。死锁预防没有银弹,核心是统一顺序 + 有界等待 + 可观测。
图/流程:
text
循环等待:
Thread-1 Thread-2
┌──────────────────┐ ┌──────────────────┐
│ locked <0x00A> │ │ locked <0x00B> │
│ waiting to lock │─────────────►│ waiting to lock │
│ <0x00B> │◄─────────────│ <0x00A> │
└──────────────────┘ └──────────────────┘
A 被 T1 持有、T2 等 A;B 被 T2 持有、T1 等 B
→ 两个线程永久 BLOCKED,形成环text
jstack -l 的关键输出(示意):
Found one Java-level deadlock:
=============================
"Thread-1":
waiting to lock monitor 0x00007f... (object 0x000000..., a java.lang.Object),
which is held by "Thread-2"
"Thread-2":
waiting to lock monitor 0x00007f... (object 0x000000..., a java.lang.Object),
which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
"Thread-1":
at com.example.Service.b(Service.java:20)
- waiting to lock <0x00000000d6f0a3b0> (a java.lang.Object)
- locked <0x00000000d6f0a3a0> (a java.lang.Object)
"Thread-2":
at com.example.Service.a(Service.java:20)
- waiting to lock <0x00000000d6f0a3a0> (a java.lang.Object)
- locked <0x00000000d6f0a3b0> (a java.lang.Object)text
锁顺序修复:
✗ 反序加锁
T1: lock(A) → lock(B)
T2: lock(B) → lock(A)
✓ 全局顺序:所有线程先 A 后 B
T1: lock(A) → lock(B)
T2: lock(A) → lock(B) // T2 在 A 上排队,不会持 B 等 Atext
带超时的 tryLock:
ReentrantLock a = ..., b = ...;
while (true) {
if (a.tryLock(100, MS)) {
try {
if (b.tryLock(100, MS)) {
try { /* 临界区 */ }
finally { b.unlock(); }
break;
}
} finally { a.unlock(); } // 拿不到 b 就释放 a
}
backoff(); // 退避,避免活锁
}text
排查决策树(多次 dump 后):
线程停在 BLOCKED / waiting to lock?
├─ 等待环稳定 + jstack 报 deadlock → 死锁:取证 → 修锁顺序/超时 → 重启
├─ 持有者在 RUNNABLE / 在推进 → 锁竞争:缩小临界区/分段锁
└─ 线程都 WAITING 等队列/Future → 线程池耗尽:拆分池/去嵌套等待
线程都 RUNNABLE 但无进展?
└─ 活锁:重试策略/退避/冲突解决有问题
个别线程长期拿不到锁?
└─ 饥饿:非公平锁/长临界区/优先级版本/源码锚点:
ThreadMXBean.findMonitorDeadlockedThreads()(Java 5)、findDeadlockedThreads()(Java 6,包含 ownable synchronizer);ThreadInfo的getLockOwnerId/getLockOwnerName/getLockedSynchronizers。jstack -l、jcmd <pid> Thread.print -l(JDK 7+)、kill -3 <pid>;JFR 的jdk.JavaMonitorEnter、jdk.ThreadPark;jdk.jfr事件可按版本确认。ReentrantLock.tryLock(long, TimeUnit)、lockInterruptibly();ReentrantReadWriteLock的写→读降级、读→写升级死锁;StampedLock不可重入。Thread.holdsLock(obj);ForkJoinPool的 join 帮助执行机制(2.4-7);ThreadPoolExecutor的队列/拒绝策略与同池嵌套(2.4-6、2.4-13)。- 数据库侧:InnoDB 等待图检测与牺牲者回滚(
innodb_deadlock_detect、SHOW ENGINE INNODB STATUS),见 4.1-10。 - 虚拟线程:传统
jstack/ThreadMXBean对虚拟线程的覆盖有限,排查用jcmd Thread.dump_to_file -format=json,具体能力按 JDK 版本确认(2.4-11)。
四个必要条件与破坏手段:
| 条件 | 含义 | 破坏手段 | 代价 |
|---|---|---|---|
| 互斥 | 资源一次只能一个线程用 | 不可变对象、并发容器、无锁结构、读写分离 | 不是所有资源都能做到 |
| 持有并等待 | 拿着一个再申请另一个 | 一次性申请全部锁;先释放再申请 | 降低并发、可能活锁 |
| 不可剥夺 | 不能强行抢走 | tryLock(timeout)、lockInterruptibly、TTL 锁 | 重试成本、状态回滚 |
| 循环等待 | 等待关系成环 | 全局锁顺序、按 id 排序、单锁化 | 需要跨代码统一约定 |
- Java 层死锁类型表:
| 类型 | 典型写法 | jstack 特征 | 处理 |
|---|---|---|---|
| monitor 死锁 | 两个 synchronized 反序嵌套 | BLOCKED + waiting to lock + locked 环 | 统一锁顺序、缩小临界区 |
| ReentrantLock 死锁 | 两个 lock() 交叉 | WAITING + parking to wait for,-l 显示 ownable synchronizer | 锁顺序 + tryLock 超时 |
| 读写锁升级 | 持读锁再 writeLock() | 同线程等待自己持有的读锁 | 改成先释放读锁再写,或重构 |
| StampedLock 自死锁 | 同一线程重复加写锁/写后加读 | 同线程等待自身 | 不可重入,改用 ReentrantLock |
| 线程池耗尽 | 父任务 submit 子任务后 get | 线程 WAITING 在 Future.get/队列 | 拆池、避免同池嵌套 |
| 数据库死锁 | 事务交叉更新/无索引大范围锁 | InnoDB 报 deadlock,应用层异常 | 固定顺序、短事务、索引、重试(4.1-10) |
| 分布式锁死锁 | 多服务锁顺序不一致/TTL 失效 | 各服务互相等待,无 JVM 栈可看 | 统一顺序、TTL+续期、fencing token、幂等 |
- 线程状态与栈特征表:
| 状态 | 常见原因 | jstack 关键字 | 是否死锁 |
|---|---|---|---|
RUNNABLE | 运行中/ native IO | at ...、socketRead0 | 单看不能判断 |
BLOCKED | 等 synchronized monitor | waiting to lock <0x...> | 有环才是死锁 |
WAITING | wait()、join()、park() | waiting on、parking to wait for | 有环/等自己是死锁 |
TIMED_WAITING | sleep、wait(t)、tryLock(t) | sleeping、parking to wait for | 通常可自愈 |
| 多线程同栈 | 池耗尽/锁竞争/死锁 | 固定栈 | 需多次 dump 对比 |
- 定位工具表:
| 工具 | 用途 | 注意 |
|---|---|---|
jstack -l <pid> | 线程栈 + 锁 + 死锁检测 | 需要 -l 才看 ownable synchronizer |
jcmd <pid> Thread.print -l | 同上,容器/新版推荐 | 与 jstack 等价 |
kill -3 <pid> | 无工具时把栈打到 stdout | 看容器日志 |
ThreadMXBean | 程序化检测死锁、接健康检查 | 虚拟线程覆盖按版本确认 |
jconsole/VisualVM | 图形化 Detect Deadlock | 生产慎用远程连接 |
arthas thread -b | 找阻塞别人的线程 | 需要 attach 权限 |
| JFR | 事后锁等待分析 | jdk.JavaMonitorEnter/ThreadPark |
| 多次线程 dump | 区分死锁/竞争/池耗尽 | 间隔几秒抓 2–3 次 |
- 死锁 vs 活锁 vs 饥饿 vs 池耗尽:
| 现象 | 线程状态 | 是否有进展 | 典型原因 | 处理 |
|---|---|---|---|---|
| 死锁 | BLOCKED/WAITING 环 | 无 | 锁顺序相反 | 修顺序/超时/重启 |
| 活锁 | RUNNABLE 反复重试 | 无 | 冲突解决策略差、无退避 | 随机退避、调整策略 |
| 饥饿 | 个别线程长期 BLOCKED | 部分有 | 非公平锁、长临界区、优先级 | 公平锁、缩小临界区 |
| 池耗尽 | 全部 WAITING 等队列/Future | 无 | 同池嵌套、下游阻塞 | 拆池、隔离、超时 |
- 常见坑清单:
| 现象 | 根因 | 处理 |
|---|---|---|
| 偶发接口卡死、重启恢复 | 锁顺序相反 | 统一锁顺序 + 压测验证 |
jstack 看不到死锁段 | 没加 -l 或等的是 AQS 锁 | 用 -l,同时看 parking to wait for |
| 线程 BLOCKED 但没死锁 | 锁竞争,持有者在推进 | 缩小临界区、分段锁 |
所有线程 WAITING 在 Future.get | 同池父子任务互相等待 | 拆线程池、避免嵌套 |
| 持锁调用 RPC,下游超时 | 临界区太长 | open call,锁外调用 |
| 读锁升级写锁卡死 | RRWL 不支持升级 | 释放读锁后再写 |
StampedLock 递归加锁卡死 | 不可重入 | 改用 ReentrantLock |
| 数据库频繁死锁 | 事务交叉更新/无索引 | 固定顺序、短事务、索引、重试 |
| 分布式锁互相等待 | 锁顺序不一致/TTL 失效 | 统一顺序、TTL、fencing token |
| 只重启不复盘 | 没定位锁顺序 | 保存 dump,修复后回归 |
| 加了超时仍卡死 | 超时后没释放已持有的锁 | try/finally 成对释放 |
| 修复后换了个入口又死锁 | 只改了一条路径的锁顺序 | 全局约定 + 代码评审/静态检查 |
深挖点(面试官常追的 6 个):
- 四条件里哪个最容易破坏:循环等待。工程上把所有锁按固定 key(业务 id、资源类型、hash)排序,所有代码路径都按同一顺序加锁,就能从根上消除环;难点是跨团队/跨模块的约定和动态多锁场景。其次是不可剥夺:
tryLock(timeout)让等待有界,失败就回滚重试;代价是重试、活锁和状态一致性。 - jstack -l 到底怎么读:先找
Found one Java-level deadlock段落,JVM 已经给出线程和锁的等待链;没有这段时,自己找waiting to lock <0x...>和locked <0x...>,把“谁等谁”连成图;AQS 锁不会显示locked,要看-l的Locked ownable synchronizers和parking to wait for。死锁线程的栈通常停在业务代码的加锁行,往上能看到调用链。 - synchronized 和 ReentrantLock 的死锁差异:
synchronized不可超时、不可中断,死锁只能靠顺序预防;ReentrantLock支持tryLock(timeout)和lockInterruptibly,可以打破不可剥夺,但要在finally里成对释放,并处理超时后的状态回滚。tryLock失败后立即重试容易变成活锁,必须加退避和随机化。 - 读写锁/StampedLock 的自死锁:RRWL 的读锁升级写锁会自己等自己(写锁要等所有读锁释放,包括自己的),必须先释放读锁再获取写锁;写锁降级读锁是允许的。
StampedLock不可重入,同一线程重复writeLock()或在写锁内readLock()会自死锁,也不能用 Condition;它的乐观读必须validate失败重试。 - 线程池耗尽为什么像死锁:父任务占着池里唯一的线程,提交子任务后
Future.get()等待;子任务在队列里排不上,形成“资源环”。jstack 看到的是所有线程WAITING在Future.get/队列上,没有 monitor 环,所以Found one Java-level deadlock不会报。解决是拆池、用独立的 IO 池、避免在池内嵌套等待,或改用结构化并发/虚拟线程。 - 数据库与分布式锁的边界:InnoDB 有等待图检测,发现死锁会回滚代价小的事务,应用层要做重试和幂等(4.1-10);分布式锁没有全局等待图,所谓死锁多是锁顺序不一致、TTL 过期、续期失败或 fencing token 缺失,靠统一顺序、TTL + 看门狗、唯一 value、幂等和超时兜底,而不是“检测后回滚”。
- 四条件里哪个最容易破坏:循环等待。工程上把所有锁按固定 key(业务 id、资源类型、hash)排序,所有代码路径都按同一顺序加锁,就能从根上消除环;难点是跨团队/跨模块的约定和动态多锁场景。其次是不可剥夺:
追问链:
- 什么是死锁? → 一组线程互相持有对方需要的锁并永久等待,形成环。
- 死锁的四个必要条件? → 互斥、持有并等待、不可剥夺、循环等待。
- 破坏哪个条件最容易? → 循环等待,用全局锁顺序。
- 怎么保证全局锁顺序? → 按业务 id/资源类型排序,所有路径统一加锁顺序。
- 动态多锁怎么排序? → 先收集所有 key,排序后再依次加锁。
- 什么是一次性获取全部锁? → 破坏持有并等待,全拿或全放。
tryLock怎么防死锁? → 带超时,失败就释放已持有的锁并退避重试。tryLock有什么风险? → 重试不当会活锁,需要退避和状态回滚。synchronized能超时吗? → 不能,也不可中断,只能靠顺序预防。ReentrantLock能中断等待吗? → 能,lockInterruptibly()。- 怎么用 jstack 找死锁? →
jstack -l <pid>找Found one Java-level deadlock。 - 为什么一定要加
-l? → 输出 ownable synchronizer,覆盖 AQS 锁。 - 没有
Found one...就说明没死锁吗? → 不一定,AQS 锁/池耗尽可能不报,要看等待环。 waiting to lock和locked怎么读? → 前者是等待的锁,后者是已持有的锁,连起来找环。parking to wait for是什么? →LockSupport.park,常见于 AQS/ReentrantLock。- 怎么程序化检测死锁? →
ThreadMXBean.findDeadlockedThreads()。 findDeadlockedThreads和findMonitorDeadlockedThreads区别? → 前者包含 ownable synchronizer,后者只查 monitor。- 能接健康检查吗? → 能,定期检测并告警/暴露指标。
- 容器里没有 jstack 怎么办? →
jcmd Thread.print、kill -3看日志,或 attach 工具。 - 为什么要多次 dump? → 区分稳定死锁、锁竞争和临时阻塞。
- 死锁和锁竞争怎么区分? → 死锁是稳定环;竞争是 BLOCKED 但持有者在推进。
- 活锁是什么? → 线程都 RUNNABLE 但一直重试/回滚,没有进展。
- 饥饿是什么? → 某些线程长期拿不到锁,通常是非公平锁/长临界区。
- 线程池耗尽和死锁有什么区别? → 池耗尽没有锁环,线程等的是队列/Future。
- 同池嵌套为什么会死锁? → 父任务占住线程等子任务,子任务在队列排不上。
- 怎么避免同池嵌套? → 拆池、独立 IO 池、避免池内等待、用结构化并发。
- 读写锁升级为什么会死锁? → 写锁要等读锁释放,包括当前线程自己的读锁。
- 读写锁能降级吗? → 能,写锁内获取读锁,再释放写锁。
- StampedLock 为什么会自死锁? → 不可重入,同一线程重复加锁会等自己。
- StampedLock 能用 Condition 吗? → 不能。
- 持锁做 IO 有什么问题? → 临界区变长,锁竞争和死锁概率上升;应 open call。
- open call 是什么? → 持锁时不调用外部/回调代码。
- 嵌套锁有什么风险? → 锁顺序难统一,容易形成环。
- 怎么减少嵌套锁? → 单锁化、分段锁、并发容器、无锁结构。
- 数据库死锁怎么处理? → 固定访问顺序、短事务、索引缩小锁范围、死锁重试(4.1-10)。
- 分布式锁会死锁吗? → 严格意义没有全局检测,多是顺序/TTL/续期问题。
- 分布式锁怎么防? → TTL + 续期、唯一 value、fencing token、幂等、超时。
- 死锁后能自动恢复吗? → JVM 不会自动解开 monitor 死锁,只能重启或让锁超时(AQS)。
- 线上死锁的止血顺序? → 先取证 dump,再摘流量/重启,最后修锁顺序并复盘。
- 只重启不复盘行吗? → 不行,锁顺序不变还会复发。
- 怎么验证修复? → 压测 + 锁顺序评审 + 混沌注入 + 监控死锁检测。
- 有没有静态检测? → 可以用代码扫描/锁顺序约定/SpotBugs 类规则,但不能完全覆盖动态路径。
- 虚拟线程死锁怎么查? →
jcmd Thread.dump_to_file -format=json,传统 jstack 覆盖有限。 - 死锁能完全避免吗? → 不能保证,但统一顺序 + 有界等待 + 可观测能把概率和影响降到很低。
- 面试怎么总结? → 四条件 → 常见形态 → jstack/ThreadMXBean 定位 → 锁顺序/超时/缩小临界区 → 区分死锁/竞争/活锁/饥饿/池耗尽 → 数据库与分布式边界。
生产案例/取舍(示例,替换成你的项目):
- 订单服务两个方法分别按“订单→库存”“库存→订单”加锁,大促时偶发卡死;统一成按资源 id 排序后不再复现。
- 持锁调用下游 RPC,下游超时导致锁持有时间过长,线程池被占满;改成锁外调用 + 本地状态校验。
tryLock超时后没有释放已持有的锁,反而制造新的死锁;补finally成对释放和状态回滚。- 单线程池里父任务
submit子任务后get,压测时全部线程卡住;拆成两个池并去掉池内等待。 - 读写锁在缓存刷新时尝试读锁升级写锁,线程自死锁;改成先释放读锁再写,或用
compute。 StampedLock在递归方法里重复加写锁,线程卡死;改用ReentrantLock。- 两个服务分布式锁加锁顺序相反,互相等待到 TTL;统一 key 顺序 + 短 TTL + 重试。
- 数据库交叉更新导致死锁,应用直接报错;加索引缩小锁范围、事务内固定顺序、捕获死锁异常重试(4.1-10)。
- 线上出现卡死只重启,没保存 dump,一周后复发;建立“先 dump 再重启”的 SOP。
- 加日志后死锁“消失”,因为日志本身持有锁/改变时序;不能靠日志判断,必须看线程栈。
- 用
jstack没看到死锁段就认为没问题,实际是 AQS 锁;加-l后看到 ownable synchronizer 环。 - 死锁检测接入健康检查后,实例自动摘流,故障影响面从全站降到单实例;配合告警定位锁顺序。
- 取舍:全局锁顺序换无死锁,代价是跨模块约定和重构;
tryLock换有界等待,代价是重试/活锁和状态回滚;缩小临界区换并发,代价是正确性审查更细;拆线程池换隔离,代价是资源与运维成本;数据库重试换可用性,代价是幂等要求。
易错点:
- 认为死锁只需要两个线程,实际多线程多资源也可能成环。
- 认为死锁只发生在
synchronized,实际 AQS 锁、读写锁、StampedLock、线程池、数据库、分布式锁都会。 - 认为破坏互斥最容易,实际工程上最常用的是破坏循环等待。
- 认为
tryLock一定防死锁,实际不释放已持有锁/不退避仍会出问题。 - 认为
synchronized可以超时,实际不能。 - 认为
ReentrantLock不会死锁,实际交叉加锁一样死。 - 认为
jstack一定能报死锁,实际 AQS 锁和池耗尽可能不报。 - 认为
jstack不加-l也能看全,实际看不到 ownable synchronizer。 - 认为线程 BLOCKED 就是死锁,实际可能只是锁竞争。
- 认为线程 WAITING 就是死锁,实际可能在等队列/IO/Future。
- 认为 RUNNABLE 就不会死锁,实际活锁线程都是 RUNNABLE。
- 认为活锁和死锁一样,实际活锁有 CPU 活动但没有进展。
- 认为饥饿是死锁,实际是长期拿不到锁,系统部分有进展。
- 认为线程池耗尽有锁环,实际没有,是资源/队列环。
- 认为同池嵌套只是慢,实际会死锁。
- 认为读写锁可以自由升级,实际读→写会自死锁。
- 认为 StampedLock 可重入,实际不可重入。
- 认为持锁调用 RPC 只是性能问题,实际会放大死锁概率。
- 认为锁越少越安全,实际锁顺序不统一时多锁更容易成环。
- 认为重启就解决了,实际锁顺序不变会复发。
- 认为加日志能帮助定位,实际日志会改变时序甚至掩盖问题。
- 认为死锁检测能自动恢复,实际 JVM 不会自动解开 monitor 死锁。
- 认为数据库死锁和 JVM 死锁一样,实际 InnoDB 会检测并回滚牺牲者。
- 认为分布式锁不会死锁,实际顺序/TTL/续期问题会造成长时间互等。
- 认为有超时就不会死锁,实际超时后不释放资源仍会。
- 认为多次 dump 没必要,实际单次 dump 分不清死锁和竞争。
- 认为虚拟线程可以用传统 jstack 排查,实际覆盖有限,要用
Thread.dump_to_file。 - 认为死锁可以完全避免,实际只能降低概率和影响,仍需监控与预案。
- 认为锁顺序只在单个类内统一就够,实际跨服务/跨模块也要统一约定。
30 秒口述稿:
死锁是一组线程互相持有对方要的锁、永久等待,必须同时满足互斥、持有并等待、不可剥夺、循环等待,破坏任意一个就能预防。Java 里最常见的是 synchronized 嵌套反序、ReentrantLock 交叉加锁、读写锁升级、StampedLock 重入、同池父子任务互等。定位用 jstack -l 或 jcmd Thread.print -l 找 Found one Java-level deadlock 和 waiting to lock / locked 环,程序化用 ThreadMXBean.findDeadlockedThreads。要注意区分死锁、锁竞争、活锁、饥饿和线程池耗尽:死锁是稳定环,竞争会推进,活锁是 RUNNABLE 但没进展,池耗尽没有锁环。预防的核心是全局锁顺序、tryLock 超时并释放已持有锁、缩小临界区、不在持锁时做 IO/RPC;线上先 dump 取证再重启,修复后压测和监控。
- 3 分钟展开顺序:结论(四条件 + 顺序/超时)→ 四条件与破坏手段 → Java 层常见死锁形态 → jstack -l 输出解读与 ThreadMXBean → 多次 dump 区分死锁/竞争/活锁/饥饿/池耗尽 → 锁顺序、tryLock、open call、缩小临界区 → 读写锁/StampedLock/线程池的专项坑 → 数据库与分布式锁边界 → 线上取证与恢复流程 → 预防清单收尾。