Skip to content

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() 做程序化检测;注意区分死锁、锁竞争、活锁、饥饿和线程池耗尽——它们在线程栈上长得很像,处理方式完全不同。

  • 分层要点:

    1. 死锁的定义与四个必要条件:两个或多个线程各自持有资源、又等待对方持有的资源,形成环,谁也无法推进。四个条件缺一不可:互斥(资源一次只能一个线程用)、持有并等待(拿着一个再要另一个)、不可剥夺(不能强行抢走)、循环等待(等待关系成环)。预防就是破坏其中任意一个,工程上最常用的是破坏循环等待(全局锁顺序)和不可剥夺(超时/可中断)。
    2. Java 层常见死锁形态:synchronized 嵌套锁顺序相反(monitor 死锁);ReentrantLock 交叉加锁;ReentrantReadWriteLock 读锁升级写锁(自己等自己释放读锁);StampedLock 不可重入导致自死锁;持锁调用回调/外部服务,回调又反向加锁;线程池里父子任务互相等待(同池嵌套、Future.get 等自己);数据库事务交叉更新(4.1-10);分布式锁顺序不一致或锁超时导致互相等待。
    3. 定位第一步:线程栈: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 锁的持有关系。
    4. 定位第二步:程序化与工具:ThreadMXBean.findDeadlockedThreads()/findMonitorDeadlockedThreads() 返回死锁线程 id,getThreadInfo(ids, true, true) 拿到锁信息,可接到健康检查/告警;jconsole/VisualVM 有 “Detect Deadlock” 按钮;arthas thread -b 直接找阻塞别人的线程;JFR 的 jdk.JavaMonitorEnter/jdk.ThreadPark 事件可做事后分析。容器里没有 jstack 时可以用 kill -3 <pid> 把线程栈打到标准输出。
    5. 区分死锁与“像死锁”的现象:死锁是稳定的环,多次 dump 线程状态和栈不变;锁竞争是 BLOCKED 但持有者在跑,过一会儿会推进;活锁是线程都 RUNNABLE 却一直重试/回滚,没有进展;饥饿是某些线程长期拿不到锁(非公平锁、优先级、长临界区);线程池耗尽是线程都停在 WAITING/TIMED_WAITING 等队列或 Future.get,但等待对象不是锁环。排查时至少连续抓 2–3 次 dump,间隔几秒,比较栈是否固定。
    6. 预防:工程手段:全局锁顺序(按业务 id/类型排序后加锁,所有路径一致);带超时的 tryLock(失败就释放已持有的锁、退避重试),lockInterruptibly 支持中断;一次性获取全部锁或“全拿或全放”;缩小临界区,持锁期间不做 IO/RPC/回调(open call);减少嵌套锁,能用一把锁或并发容器就不用多把;线程池隔离,避免父任务在同池里等子任务;数据库事务短、按固定顺序访问、加索引缩小锁范围、死锁后重试(4.1-10)。
    7. 恢复流程:先取证(多次线程 dump、top -Hp、GC/监控),再止血(摘流量、重启实例、回滚变更),最后定位锁顺序并修复;不要只重启不复盘,否则下次还会发生。线上可以用 jstack 输出里的锁地址在两次 dump 间对比,确认环是否稳定;修复后用压测/混沌注入验证锁顺序和超时路径。
    8. 边界与取舍: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 等 A
text
带超时的 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 IOat ...、socketRead0单看不能判断
BLOCKED等 synchronized monitorwaiting to lock <0x...>有环才是死锁
WAITINGwait()、join()、park()waiting on、parking to wait for有环/等自己是死锁
TIMED_WAITINGsleep、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 个):

    1. 四条件里哪个最容易破坏:循环等待。工程上把所有锁按固定 key(业务 id、资源类型、hash)排序,所有代码路径都按同一顺序加锁,就能从根上消除环;难点是跨团队/跨模块的约定和动态多锁场景。其次是不可剥夺:tryLock(timeout) 让等待有界,失败就回滚重试;代价是重试、活锁和状态一致性。
    2. jstack -l 到底怎么读:先找 Found one Java-level deadlock 段落,JVM 已经给出线程和锁的等待链;没有这段时,自己找 waiting to lock <0x...> 和 locked <0x...>,把“谁等谁”连成图;AQS 锁不会显示 locked,要看 -l 的 Locked ownable synchronizers 和 parking to wait for。死锁线程的栈通常停在业务代码的加锁行,往上能看到调用链。
    3. synchronized 和 ReentrantLock 的死锁差异:synchronized 不可超时、不可中断,死锁只能靠顺序预防;ReentrantLock 支持 tryLock(timeout) 和 lockInterruptibly,可以打破不可剥夺,但要在 finally 里成对释放,并处理超时后的状态回滚。tryLock 失败后立即重试容易变成活锁,必须加退避和随机化。
    4. 读写锁/StampedLock 的自死锁:RRWL 的读锁升级写锁会自己等自己(写锁要等所有读锁释放,包括自己的),必须先释放读锁再获取写锁;写锁降级读锁是允许的。StampedLock 不可重入,同一线程重复 writeLock() 或在写锁内 readLock() 会自死锁,也不能用 Condition;它的乐观读必须 validate 失败重试。
    5. 线程池耗尽为什么像死锁:父任务占着池里唯一的线程,提交子任务后 Future.get() 等待;子任务在队列里排不上,形成“资源环”。jstack 看到的是所有线程 WAITING 在 Future.get/队列上,没有 monitor 环,所以 Found one Java-level deadlock 不会报。解决是拆池、用独立的 IO 池、避免在池内嵌套等待,或改用结构化并发/虚拟线程。
    6. 数据库与分布式锁的边界:InnoDB 有等待图检测,发现死锁会回滚代价小的事务,应用层要做重试和幂等(4.1-10);分布式锁没有全局等待图,所谓死锁多是锁顺序不一致、TTL 过期、续期失败或 fencing token 缺失,靠统一顺序、TTL + 看门狗、唯一 value、幂等和超时兜底,而不是“检测后回滚”。
  • 追问链:

    1. 什么是死锁? → 一组线程互相持有对方需要的锁并永久等待,形成环。
    2. 死锁的四个必要条件? → 互斥、持有并等待、不可剥夺、循环等待。
    3. 破坏哪个条件最容易? → 循环等待,用全局锁顺序。
    4. 怎么保证全局锁顺序? → 按业务 id/资源类型排序,所有路径统一加锁顺序。
    5. 动态多锁怎么排序? → 先收集所有 key,排序后再依次加锁。
    6. 什么是一次性获取全部锁? → 破坏持有并等待,全拿或全放。
    7. tryLock 怎么防死锁? → 带超时,失败就释放已持有的锁并退避重试。
    8. tryLock 有什么风险? → 重试不当会活锁,需要退避和状态回滚。
    9. synchronized 能超时吗? → 不能,也不可中断,只能靠顺序预防。
    10. ReentrantLock 能中断等待吗? → 能,lockInterruptibly()。
    11. 怎么用 jstack 找死锁? → jstack -l <pid> 找 Found one Java-level deadlock。
    12. 为什么一定要加 -l? → 输出 ownable synchronizer,覆盖 AQS 锁。
    13. 没有 Found one... 就说明没死锁吗? → 不一定,AQS 锁/池耗尽可能不报,要看等待环。
    14. waiting to lock 和 locked 怎么读? → 前者是等待的锁,后者是已持有的锁,连起来找环。
    15. parking to wait for 是什么? → LockSupport.park,常见于 AQS/ReentrantLock。
    16. 怎么程序化检测死锁? → ThreadMXBean.findDeadlockedThreads()。
    17. findDeadlockedThreads 和 findMonitorDeadlockedThreads 区别? → 前者包含 ownable synchronizer,后者只查 monitor。
    18. 能接健康检查吗? → 能,定期检测并告警/暴露指标。
    19. 容器里没有 jstack 怎么办? → jcmd Thread.print、kill -3 看日志,或 attach 工具。
    20. 为什么要多次 dump? → 区分稳定死锁、锁竞争和临时阻塞。
    21. 死锁和锁竞争怎么区分? → 死锁是稳定环;竞争是 BLOCKED 但持有者在推进。
    22. 活锁是什么? → 线程都 RUNNABLE 但一直重试/回滚,没有进展。
    23. 饥饿是什么? → 某些线程长期拿不到锁,通常是非公平锁/长临界区。
    24. 线程池耗尽和死锁有什么区别? → 池耗尽没有锁环,线程等的是队列/Future。
    25. 同池嵌套为什么会死锁? → 父任务占住线程等子任务,子任务在队列排不上。
    26. 怎么避免同池嵌套? → 拆池、独立 IO 池、避免池内等待、用结构化并发。
    27. 读写锁升级为什么会死锁? → 写锁要等读锁释放,包括当前线程自己的读锁。
    28. 读写锁能降级吗? → 能,写锁内获取读锁,再释放写锁。
    29. StampedLock 为什么会自死锁? → 不可重入,同一线程重复加锁会等自己。
    30. StampedLock 能用 Condition 吗? → 不能。
    31. 持锁做 IO 有什么问题? → 临界区变长,锁竞争和死锁概率上升;应 open call。
    32. open call 是什么? → 持锁时不调用外部/回调代码。
    33. 嵌套锁有什么风险? → 锁顺序难统一,容易形成环。
    34. 怎么减少嵌套锁? → 单锁化、分段锁、并发容器、无锁结构。
    35. 数据库死锁怎么处理? → 固定访问顺序、短事务、索引缩小锁范围、死锁重试(4.1-10)。
    36. 分布式锁会死锁吗? → 严格意义没有全局检测,多是顺序/TTL/续期问题。
    37. 分布式锁怎么防? → TTL + 续期、唯一 value、fencing token、幂等、超时。
    38. 死锁后能自动恢复吗? → JVM 不会自动解开 monitor 死锁,只能重启或让锁超时(AQS)。
    39. 线上死锁的止血顺序? → 先取证 dump,再摘流量/重启,最后修锁顺序并复盘。
    40. 只重启不复盘行吗? → 不行,锁顺序不变还会复发。
    41. 怎么验证修复? → 压测 + 锁顺序评审 + 混沌注入 + 监控死锁检测。
    42. 有没有静态检测? → 可以用代码扫描/锁顺序约定/SpotBugs 类规则,但不能完全覆盖动态路径。
    43. 虚拟线程死锁怎么查? → jcmd Thread.dump_to_file -format=json,传统 jstack 覆盖有限。
    44. 死锁能完全避免吗? → 不能保证,但统一顺序 + 有界等待 + 可观测能把概率和影响降到很低。
    45. 面试怎么总结? → 四条件 → 常见形态 → 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/线程池的专项坑 → 数据库与分布式锁边界 → 线上取证与恢复流程 → 预防清单收尾。