知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 06 - 死锁的产生与排查 > 导读:用一问一答的方式,讲清死锁的四个必要条件、如何用一段代码复现死锁、如何用 jstack 与 ThreadMXBean 定位死锁,以及三种可落地的预防手段。适合需要处理线上线程卡死、并发问题的 Java 后端读者。 ## 一、先建立全局认知 ### Q:什么是死锁?面试原题怎么问? A:面试官通常这样问: > "什么是死锁?如何产生?如何排查和预防?" 死锁(Deadlock)指两个或多个线程互相持有对方需要的资源,又都在等待对方释放,导致它们永久阻塞、谁也无法继续执行。它有三个特征值得记住: 1. **是"互相等待"而不是"单方等待"**:A 等 B、B 等 A,形成闭环; 2. **不抛异常、不打日志**:线程只是安静地卡住,所以排查往往比修复更难; 3. **可能发生在任何共享资源上**:锁、数据库连接、线程池、文件句柄都算资源。 ### Q:死锁产生的四个必要条件是什么? A:这是理解死锁的全局模型,四个条件缺一不可: ```text 1. 互斥条件:资源同一时刻只能被一个线程持有 2. 持有并等待:线程持有资源的同时,等待其他资源 3. 不可剥夺:线程持有的资源不能被强制剥夺,只能主动释放 4. 循环等待:线程之间形成循环等待链(A 等 B,B 等 A) 四个条件同时满足才会死锁,破坏任意一个即可预防 ```  [编辑 Excalidraw 源图](/images/java-interview-copy/concurrent/06-deadlock-deadlock-circular-wait-diagram.excalidraw) ### Q:为什么强调"四个条件同时满足"才死锁? A:因为这四个条件是一组"与"关系,只要破坏其中任意一个,环路就断了,因此预防死锁的所有手段本质上都是在破坏其中之一: - 破坏**互斥**:把独占资源改成可共享(如用读写锁、无锁结构、不可变对象)。代价最大,很多场景做不到。 - 破坏**持有并等待**:一次性申请全部资源,或者拿不到就释放已持有的,对应后文的 `tryLock` 超时方案。 - 破坏**不可剥夺**:加超时,超时后主动释放(`tryLock` 也属于这一类)。 - 破坏**循环等待**:约定全局统一的加锁顺序,对应后文的"固定加锁顺序"方案。 想清楚这层映射,面试时就不会把"四个条件"和"三种预防手段"背成两段互不相干的知识。 ## 二、理解核心机制 ### Q:能写一段必然死锁的代码吗? A:可以。下面这段代码用两把锁、两个线程、相反的加锁顺序,稳定复现死锁: ```java public class DeadlockDemo { private static final Object lockA = new Object(); private static final Object lockB = new Object(); public static void main(String[] args) { Thread t1 = new Thread(() -> { synchronized (lockA) { System.out.println("线程1 获得 lockA"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockB) { // 等待 lockB System.out.println("线程1 获得 lockB"); } } }); Thread t2 = new Thread(() -> { synchronized (lockB) { System.out.println("线程2 获得 lockB"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lockA) { // 等待 lockA System.out.println("线程2 获得 lockA"); } } }); t1.start(); t2.start(); // 线程1 持有 lockA 等 lockB,线程2 持有 lockB 等 lockA → 死锁 } } ``` **关键点与取舍**: - 这里的 `Thread.sleep(100)` 是"放大器":它人为制造出"两个线程都拿到第一把锁之后再尝试第二把"的窗口。去掉它程序也可能死锁,只是概率更低、更随机。 - 这段代码故意用了相反顺序的 `lockA → lockB` 和 `lockB → lockA`,正好凑齐"循环等待"。 - 这类"演示代码"不能直接抄进生产,但它是最标准的排查练习素材:跑起来后用下面的工具去抓。 ### Q:如何用 jstack 排查线上死锁? A:`jstack` 是 JDK 自带的线程堆栈打印工具,能直接告诉你"谁在等谁"。分两步: ```bash # 1. 找到 Java 进程 ID jps -l # 2. 打印线程堆栈 jstack <pid> # 输出中会有: # Found one Java-level deadlock: # ============================= # "Thread-1": # waiting to lock monitor 0x... (object 0x..., a java.lang.Object) # which is held by "Thread-0" # "Thread-0": # waiting to lock monitor 0x... (object 0x..., a java.lang.Object) # which is held by "Thread-1" ``` **怎么读这段输出**: - `Found one Java-level deadlock:` 是 JVM 给出的明确结论,有它就是死锁,不用自己猜。 - 两个线程各自"waiting to lock"对方持有的 monitor(管程/内置锁),这就构成了循环等待链。 - `jps -l` 列出本机 Java 进程和主类,用来拿到 `<pid>`;`jstack <pid>` 是纯快照命令,对线上进程基本无侵入,是排查卡死问题的首选。 - 生产上通常连续打印几份堆栈(间隔几秒)对比,确认线程确实是"卡住不动"而不是"正在处理慢逻辑"。 ### Q:如何在代码里主动检测死锁? A:除了事后用工具抓,还可以在程序内部用 `ThreadMXBean` 主动探测: ```java ThreadMXBean bean = ManagementFactory.getThreadMXBean(); long[] deadlockedThreads = bean.findDeadlockedThreads(); if (deadlockedThreads != null) { ThreadInfo[] infos = bean.getThreadInfo(deadlockedThreads, true, true); for (ThreadInfo info : infos) { System.out.println(info.toString()); } } ``` **取舍分析**: - `findDeadlockedThreads()` 返回陷入死锁的线程 ID 数组,没有死锁时返回 `null`;拿到 ID 后再用 `getThreadInfo` 取详细信息(`true, true` 表示同时抓取锁信息和堆栈信息)。 - 这套 API 很轻量,适合放进监控定时任务或健康检查接口:一旦返回非 `null` 就告警,甚至可以把堆栈打到日志里留证。 - 它只能发现 JVM 能识别的锁死锁(monitor、`ReentrantLock` 等);对于"线程池耗尽""数据库连接等不到"这类资源层面的死锁,JVM 判不出来,仍然要靠 jstack + 业务分析。 ## 三、放进真实场景 ### Q:预防死锁方法一——固定加锁顺序(破坏循环等待)怎么做? A:核心思路是让所有线程以**同一个全局顺序**获取锁,这样就不可能形成环: ```java // 错误:不同线程加锁顺序不同 // 线程1:lockA → lockB // 线程2:lockB → lockA // 正确:所有线程按相同顺序加锁 // 线程1:lockA → lockB // 线程2:lockA → lockB(改变顺序) // 对于动态资源(如转账),按 ID 排序 public void transfer(Account from, Account to, double amount) { Account first = from.getId() < to.getId() ? from : to; Account second = from.getId() < to.getId() ? to : from; synchronized (first) { synchronized (second) { from.debit(amount); to.credit(amount); } } } ``` **为什么这样写、适用场景**: - 静态资源(固定几个锁对象)用"约定顺序"最简单;动态资源(如转账涉及任意两个账户)则用"按 ID 排序"把顺序强制归一——无论谁转给谁,都先锁 ID 小的账户。 - 代价是:加锁顺序一旦被某处代码破坏(比如新同事随手加了个不同顺序的锁),死锁又会回来。所以最好把它固化成编码规范或封装成统一的 `LockOrder` 工具类。 - 适用:加锁对象可比较、可排序的场景。这是破坏"循环等待"的标准手段。 ### Q:预防死锁方法二——tryLock 超时(破坏持有并等待)怎么做? A:用 `ReentrantLock.tryLock(timeout)` 代替无限等待的 `synchronized`,拿不到就放弃并重试: ```java ReentrantLock lockA = new ReentrantLock(); ReentrantLock lockB = new ReentrantLock(); public boolean transfer() throws InterruptedException { while (true) { if (lockA.tryLock(100, TimeUnit.MILLISECONDS)) { try { if (lockB.tryLock(100, TimeUnit.MILLISECONDS)) { try { // 执行业务逻辑 return true; } finally { lockB.unlock(); } } } finally { lockA.unlock(); } } // 获取锁失败,等待随机时间后重试(避免活锁) Thread.sleep(new Random().nextInt(100)); } } ``` **为什么这样写、代价是什么**: - 关键在于"拿不到第二把锁就释放第一把":由内层 `finally` 释放 `lockB`、外层 `finally` 释放 `lockA`,从而打破"持有并等待"。 - 重试前 `Thread.sleep` 一个**随机**时间,是为了避免所有线程同频重试导致的**活锁**(大家步调一致,反复互相谦让,谁也进不去)。 - 代价:代码复杂度上升,还要处理"一直重试仍失败"的降级/超时退出;但换来的是"无论如何不会永久卡死"。 - 适用:需要可中断、可超时、可放弃的加锁场景;`synchronized` 做不到这一点。 ### Q:预防死锁方法三——减少锁的粒度和持有时间,有什么讲究? A:锁持有时间越长、临界区越大,发生死锁和性能问题(锁竞争)的概率越高: ```java // 不好:持有锁的时间太长 synchronized (lock) { doSomethingFast(); doSomethingSlow(); // 慢操作也在锁里 doSomethingElse(); } // 好:只在必要时加锁 doSomethingFast(); synchronized (lock) { // 只锁住真正需要保护的代码 updateSharedState(); } doSomethingElse(); ``` **取舍分析**: - 原则是"能不在锁里做的事,就不要放在锁里",尤其是 I/O、远程调用、`sleep` 这类慢操作。 - 但缩小临界区不能破坏业务上的原子性:如果 `doSomethingFast`、`updateSharedState`、`doSomethingElse` 之间存在必须整体一致的约束,就不能随意拆。这需要结合业务语义判断,不是一个纯技术规则。 - 适用:几乎所有并发场景,是最基础的"优化"手段;它主要降低竞争和死锁概率,但不像前两种那样能给出"绝不死锁"的保证。 ### Q:死锁和活锁的区别? A:死锁是线程永久阻塞等待,线程处于 `BLOCKED`/`WAITING` 状态,完全不动;活锁是线程没有阻塞,但一直在重试却无法推进,CPU 可能还在空转(比如两个人在走廊相遇,都不断让路但方向相同,谁也没走成)。 两者的处理思路也不同:死锁要靠破坏四个必要条件、或者超时放弃;活锁通常通过引入**随机等待时间**(如上面 `tryLock` 示例里的随机 sleep)来打破同步的让路节奏。 ### Q:`synchronized` 和 `ReentrantLock` 在死锁处理上有什么区别? A:核心差异在于"能不能超时放弃": - `synchronized` 是 JVM 内置的管程锁,无法设置超时,一旦进入等待就会一直等下去,线程也无法响应中断(等待锁时),所以它一旦死锁就只能靠外部工具发现。 - `ReentrantLock` 的 `tryLock(timeout)` 可以设置超时时间,获取锁失败后可以放弃并重试,还能响应中断,因此更容易避免死锁、也更可控。 - 但 `ReentrantLock` 需要手动 `unlock`(务必放在 `finally` 里),代码更啰嗦、更容易漏写释放。所以常规场景优先 `synchronized`,需要超时/中断/公平锁等高级能力时再用 `ReentrantLock`。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"定义 → 成因 → 排查 → 预防"四步作答: 1. **定义**:死锁是多个线程互相持有对方所需资源并互相等待,形成永久阻塞;表现为线程卡死、不报错。 2. **成因**:同时满足互斥、持有并等待、不可剥夺、循环等待四个必要条件;破坏任一即可预防。 3. **排查**:用 `jps -l` 拿 PID,再 `jstack <pid>`,看输出里的 `Found one Java-level deadlock` 和 "which is held by" 链条;也可以在代码里用 `ThreadMXBean.findDeadlockedThreads()` 主动探测。 4. **预防**:固定加锁顺序(破坏循环等待)、`tryLock` 超时(破坏持有并等待)、缩小锁粒度与持有时间,三者可组合使用。 ### Q:线上真的遇到死锁,处理流程应该是什么? A: 1. **先恢复**:如果影响核心链路,优先重启/切流止损(注意重启前先抓堆栈,否则现场就没了)。 2. **留证**:`jstack` 连续抓几份堆栈,确认死锁线程和它们持有的锁。 3. **定位代码**:根据线程名和堆栈定位到具体业务代码,找出加锁顺序不一致的地方。 4. **修复**:统一加锁顺序,或改用 `tryLock` 超时;补充监控告警,防止再犯。 --- ## 自测 1. 说出死锁的四个必要条件,并各举一种"破坏它"的手段。 2. 用 `jstack` 排查死锁时,你在输出里找的关键字是什么?它说明了什么? 3. 为什么 `tryLock` 失败后要"随机"等待再重试,而不是固定时间或立即重试?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入