qinyelin
发布于 2026-11-16 / 2 阅读
0
0

MySQL 死锁

面试频率:★★★★★
预计学习:60 分钟
适用岗位:Java 后端(3~5 年经验)
核心重点:死锁原理、线上排查、优化方案、业务场景


⚡ 30 秒速记

🟢 一句话

MySQL 死锁是多个事务互相持有对方需要的锁,形成循环等待,导致事务无法继续执行。

核心流程:

事务 A 锁住记录 1
        ↓
事务 B 锁住记录 2
        ↓
事务 A 等待记录 2
        ↓
事务 B 等待记录 1
        ↓
形成循环等待
        ↓
发生死锁

排查与解决记住五个关键词:

死锁
 ↓
定位 SQL
 ↓
分析锁等待
 ↓
优化事务与索引
 ↓
有限重试

面试口诀:

原因看循环等待,排查看 InnoDB Status,优化靠顺序、索引和短事务,兜底靠重试与幂等。


🎤 一、面试标准回答 ⭐⭐⭐⭐⭐

Q:MySQL 为什么会发生死锁?线上出现死锁怎么排查和解决?

标准回答(1~2 分钟)

MySQL 死锁通常是两个或多个事务互相持有对方需要的锁,形成循环等待,导致事务无法继续执行。

例如事务 A 先更新记录 1,再更新记录 2;事务 B 先更新记录 2,再更新记录 1。如果两个事务交叉执行,就可能发生死锁。

线上排查时,我一般会分为五个步骤:

第一,定位问题。

先查看应用日志,确认发生死锁的接口、SQL 和异常信息,判断死锁是否集中在某些高并发业务上。

第二,查看死锁日志。

通过:

SHOW ENGINE INNODB STATUS\G

查看最近一次死锁信息,重点分析涉及的事务、SQL、持有的锁、等待的锁以及相关索引。

第三,分析死锁原因。

重点检查:

  • 不同事务是否以不同顺序更新相同记录。
  • SQL 是否缺少合适索引,导致锁范围扩大。
  • 事务是否执行时间过长。
  • 是否存在不必要的锁竞争。

第四,针对性优化。

通过统一加锁顺序、优化 SQL 和索引、缩短事务执行时间等方式,降低死锁发生概率。

第五,异常兜底。

InnoDB 默认开启死锁检测,检测到死锁后通常会回滚其中一个事务。

因此业务层需要对适合重试的操作增加有限次数的事务重试,同时保证幂等性。

最后总结

MySQL 死锁排查的核心是:定位冲突 SQL、分析锁等待关系、优化事务加锁顺序和索引,并通过有限重试保证业务可靠性。


📚 二、MySQL 死锁的底层原理 ⭐⭐⭐⭐⭐

1. 什么是死锁?

死锁是指两个或多个事务之间形成循环等待。

例如:

事务 A
  │
  ├── 持有记录 1 的锁
  │
  └── 等待记录 2 的锁
             ↑
             │
           事务 B
             │
             ├── 持有记录 2 的锁
             │
             └── 等待记录 1 的锁
                         ↑
                         │
                       事务 A

最终:

A 等 B
  +
B 等 A
  ↓
死锁

注意:锁等待不一定是死锁,形成循环等待才是死锁。

2. SQL 示例

假设有一张账户表:

CREATE TABLE account (
    id BIGINT PRIMARY KEY,
    balance DECIMAL(10, 2)
) ENGINE = InnoDB;

数据:

idbalance
11000
22000

事务 A

BEGIN;

UPDATE account
SET balance = balance - 100
WHERE id = 1;

UPDATE account
SET balance = balance + 100
WHERE id = 2;

COMMIT;

事务 B

BEGIN;

UPDATE account
SET balance = balance - 50
WHERE id = 2;

UPDATE account
SET balance = balance + 50
WHERE id = 1;

COMMIT;

交叉执行过程

第一步:

事务 A 更新 id=1。

事务 A
  ↓
获得 id=1 的排他锁

第二步:

事务 B 更新 id=2。

事务 B
  ↓
获得 id=2 的排他锁

第三步:

事务 A 尝试更新 id=2。

id=2 已经被 B 锁住
        ↓
事务 A 等待 B

第四步:

事务 B 尝试更新 id=1。

id=1 已经被 A 锁住
        ↓
事务 B 等待 A

最终:

事务 A 等待 B
       ↑
       │
       ↓
事务 B 等待 A
       ↓
      死锁

3. 为什么 UPDATE 会导致死锁?

因为 InnoDB 在更新记录时,需要获取相应的排他锁(X 锁)。

排他锁具有互斥性。

例如:

事务 A
  ↓
持有 id=1 的 X 锁

此时事务 B:

想获得 id=1 的 X 锁
       ↓
发生冲突
       ↓
必须等待

如果事务 A 又等待事务 B 持有的锁,就可能形成死锁。

核心结论

UPDATE 本身不一定导致死锁。真正的问题是多个事务获取锁的顺序和范围形成了循环等待。


📚 三、InnoDB 如何处理死锁? ⭐⭐⭐⭐⭐

1. 死锁检测

InnoDB 默认开启死锁检测。

查看配置:

SHOW VARIABLES LIKE 'innodb_deadlock_detect';

默认通常为:

ON

当 InnoDB 检测到事务之间存在死锁时,会尝试主动解除死锁。

2. 选择一个事务回滚

例如:

事务 A
  ↓
等待事务 B

事务 B
  ↓
等待事务 A

InnoDB 检测到死锁
  ↓
选择一个事务作为牺牲者
  ↓
回滚该事务
  ↓
释放相关锁
  ↓
其他事务继续执行

InnoDB 通常倾向于选择回滚代价较小的事务。

但不能简单认为:

  • 一定回滚后启动的事务。
  • 一定回滚执行时间短的事务。
  • 一定回滚事务 B。

面试重点

InnoDB 默认可以自动检测并解除死锁,但不能自动保证被回滚的业务操作最终成功。

因此应用层需要正确处理死锁异常。


🔥 四、业务场景:线上订单系统频繁死锁 ⭐⭐⭐⭐⭐

面试官:订单系统高并发更新时频繁发生死锁,你会怎么处理?

🎤 标准回答

如果订单系统频繁出现死锁,我首先会通过应用日志确认发生死锁的业务接口和 SQL,例如订单状态更新、库存扣减或者账户余额更新。

然后通过 SHOW ENGINE INNODB STATUS 查看最近一次死锁详情,分析参与死锁的事务、锁等待关系和相关索引。

接下来结合 SQL 执行计划和事务代码,判断是否存在不同事务加锁顺序不一致、索引不合理导致锁范围扩大、事务执行时间过长等问题。

找到原因后,我会优先统一加锁顺序、优化 SQL 和索引、缩短事务执行时间。

对于偶发死锁,可以在业务层增加有限次数的事务重试,并保证幂等性。

最后通过并发测试和数据库监控,确认优化后死锁发生频率是否下降。


🔥 五、线上死锁排查步骤 ⭐⭐⭐⭐⭐

第一步:查看应用日志

常见异常:

Deadlock found when trying to get lock;
try restarting transaction

MySQL 常见死锁错误码:

1213

重点定位:

  • 哪个接口发生异常。
  • 哪条 SQL 发生异常。
  • 是否集中在某些业务操作。
  • 是否存在高并发更新。
  • 是否可以关联具体事务和请求日志。

第二步:查看最近一次死锁

执行:

SHOW ENGINE INNODB STATUS\G

重点关注:

LATEST DETECTED DEADLOCK

通常可以看到:

事务信息
   ↓
正在执行的 SQL
   ↓
已经持有的锁
   ↓
正在等待的锁
   ↓
被回滚的事务

注意

SHOW ENGINE INNODB STATUS 通常只显示最近一次检测到的死锁。

不能把它当作完整的历史死锁记录。

第三步:记录所有检测到的死锁

可以开启:

SET GLOBAL innodb_print_all_deadlocks = ON;

开启后,检测到的死锁会写入 MySQL 错误日志。

适合排查频繁发生但不容易现场复现的死锁。

生产环境需要考虑权限、日志量和日志保留策略。

第四步:查看当前锁等待

MySQL 8.0 可以查询:

SELECT *
FROM performance_schema.data_lock_waits;

作用:

查看当前事务之间的锁等待关系。

注意:

data_lock_waits
    ↓
当前锁等待
    ≠
历史死锁记录

死锁解除后,相关等待信息可能已经消失。

第五步:分析 SQL 和索引

例如:

EXPLAIN
SELECT *
FROM orders
WHERE user_id = 1001
  AND status = 1;

重点关注:

字段作用
type访问类型
key实际使用的索引
rows预估扫描行数
Extra额外执行信息

排查时还需要结合真正发生冲突的 UPDATE、DELETE 或锁定读 SQL。

如果缺少合适索引,数据库可能扫描并锁定更多记录,增加锁冲突风险。

但不能认为加了索引就一定不会死锁。


🔥 六、死锁的常见解决方案 ⭐⭐⭐⭐⭐

方案一:统一加锁顺序

场景:账户转账

假设两个账户:

账户 A:id=1
账户 B:id=2

存在两个并发事务:

事务 1:A 转 B
先锁 A
再锁 B
事务 2:B 转 A
先锁 B
再锁 A

容易形成:

事务 1 等待 B
事务 2 等待 A
       ↓
      死锁

优化方案

无论转账方向如何,都按照账户 ID 从小到大的顺序加锁。

事务 1:
先锁 id=1
再锁 id=2
事务 2:
先锁 id=1
再锁 id=2

这样可以避免这个特定场景中的反向加锁问题。

面试总结

对多个资源进行加锁时,尽量统一加锁顺序,减少循环等待的形成机会。


方案二:优化 SQL 和索引

假设存在:

UPDATE orders
SET status = 2
WHERE user_id = 1001
  AND status = 1;

如果缺少合适索引,可能导致扫描和锁定范围扩大。

可以根据实际查询条件和数据分布,评估建立联合索引:

CREATE INDEX idx_user_status
ON orders(user_id, status);

但不能盲目添加索引。

需要考虑:

  • SQL 实际执行计划。
  • 查询条件的选择性。
  • 索引维护成本。
  • 并发更新场景。
  • 是否真正减少锁冲突。

面试总结

合理索引可以减少部分 SQL 的扫描和加锁范围,从而降低死锁概率,但不能彻底消除死锁。


方案三:缩短事务执行时间

不推荐在数据库事务中执行耗时的远程调用。

例如:

@Transactional
public void createOrder() {
    saveOrder();

    // 可能耗时数秒
    remoteService.call();

    updateStock();
}

问题:

开启事务
   ↓
写入订单
   ↓
持有相关锁
   ↓
远程接口调用
   ↓
等待数秒
   ↓
更新库存
   ↓
提交事务

事务执行时间越长,锁可能被持有越久。

优化思路:

  1. 减少事务中不必要的操作。
  2. 避免持有数据库锁时执行耗时远程调用。
  3. 合理拆分事务和业务流程。
  4. 如果拆分涉及跨系统一致性,需要配套补偿、消息或其他一致性机制。

面试总结

缩短事务执行时间可以减少持锁时间,降低锁冲突概率。


方案四:死锁重试

InnoDB 发生死锁后,通常会回滚一个事务。

应用层可以针对适合重试的业务增加有限重试。

例如:

执行事务
   ↓
发生死锁
   ↓
数据库回滚事务
   ↓
应用识别死锁异常
   ↓
适当退避
   ↓
重新开启事务
   ↓
重新执行完整业务

注意事项

1. 重试整个事务

不能只重试失败的 SQL。

2. 重试必须发生在新的事务中

不能在已经回滚的事务上下文中继续执行。

3. 保证业务幂等

避免:

  • 重复扣款。
  • 重复创建订单。
  • 重复发送消息。

4. 限制重试次数

例如最多重试 3 次,避免无限重试增加数据库压力。

5. 必要时加入退避

避免多个事务立即同时重试,再次发生激烈竞争。

面试总结

死锁重试是兜底方案,根本优化仍然是减少锁冲突和循环等待。


🎯 七、高频面试追问 ⭐⭐⭐⭐⭐

Q1:死锁和普通锁等待有什么区别?

🎤 标准回答

普通锁等待是一个事务等待另一个事务释放锁。

只要持锁事务提交或者回滚,等待事务通常就有机会继续执行。

死锁则是多个事务之间形成循环等待,例如事务 A 等待 B,事务 B 又等待 A,导致事务无法正常推进。

核心区别:是否形成循环等待。


Q2:READ COMMITTED 隔离级别会发生死锁吗?

🎤 标准回答

会。

虽然 READ COMMITTED 隔离级别下,InnoDB 通常减少了 Gap Lock 的使用,但仍然存在行锁。

如果两个事务以不同顺序更新相同记录,依然可能形成循环等待。

所以死锁不是 REPEATABLE READ 独有的问题。

RC 和 RR 都可能发生死锁。


Q3:建立索引就能避免死锁吗?

🎤 标准回答

不能。

合理索引可以减少部分 SQL 的扫描和加锁范围,降低锁冲突概率。

但即使两个事务都通过主键索引更新记录,只要加锁顺序不同,仍然可能发生死锁。

例如:

事务 A:
更新 id=1
更新 id=2

事务 B:
更新 id=2
更新 id=1

即使都使用主键索引,也可能形成循环等待。

索引只能降低部分死锁风险,不能保证完全避免。


Q4:MySQL 发生死锁后,会自动处理吗?

🎤 标准回答

InnoDB 默认开启死锁检测。

检测到死锁后,通常会选择一个事务作为牺牲者进行回滚,解除循环等待,让其他事务继续执行。

但是数据库只能处理锁层面的死锁,不能保证被回滚的业务操作最终成功。

因此应用层仍然需要正确处理死锁异常。


Q5:Java 中如何处理 MySQL 死锁异常?

🎤 标准回答

Java 应用可以识别 MySQL 返回的死锁异常,例如错误码 1213。

对于允许重试的业务,可以在事务边界增加有限次数的重试,并配合适当的退避策略。

需要注意:

第一,重新执行完整事务,而不是只重试失败的 SQL。

第二,重试必须在新的事务中执行。

第三,保证业务幂等性,避免重复扣款或者重复创建订单。

如果使用 Spring,可以通过事务外层的重试逻辑或者合适的重试组件实现,但要正确处理事务边界和代理调用。


Q6:为什么统一更新顺序可以减少死锁?

🎤 标准回答

因为死锁经常与不同事务获取锁的顺序不一致有关。

例如事务 A 先锁记录 1,再锁记录 2;事务 B 先锁记录 2,再锁记录 1,就可能形成循环等待。

如果多个事务都按照记录 ID 从小到大的顺序获取锁,就可以减少这个场景中的循环等待。

但统一加锁顺序不能保证完全没有死锁,因为还可能涉及不同索引、范围锁和其他锁资源。


⚠️ 八、面试易错点

1. 死锁不等于锁等待超时

死锁

多个事务
   ↓
循环等待
   ↓
InnoDB 检测
   ↓
回滚一个事务

锁等待超时

事务等待锁
   ↓
超过 innodb_lock_wait_timeout
   ↓
返回锁等待超时错误

锁等待超时不一定存在循环等待。

默认情况下,锁等待超时通常只回滚失败的语句,而不是整个事务;具体行为还受配置影响。


2. RC 隔离级别也可能发生死锁

不要认为只有 RR 会发生死锁。

RC 下仍然存在行锁冲突。


3. 有索引不代表不会死锁

即使使用主键索引,也可能因为不同事务的加锁顺序不一致而发生死锁。


4. 死锁回滚不代表业务自动成功

数据库回滚事务后,应用需要处理异常。

适合重试的业务可以重新执行完整事务。


5. 不能无限重试

无限重试可能进一步增加数据库压力。

应该:

  • 限制重试次数。
  • 采用适当退避。
  • 保证幂等。
  • 监控重试失败率。

6. SHOW ENGINE INNODB STATUS 不是历史死锁列表

它通常只展示最近一次检测到的死锁。

需要持续记录死锁时,可以考虑开启:

SET GLOBAL innodb_print_all_deadlocks = ON;

📝 九、考前速记

1. 什么是死锁?

多个事务互相持有对方需要的锁,形成循环等待。

2. 为什么发生死锁?

多个事务获取锁的顺序和范围形成循环等待。

3. 怎么排查死锁?

应用日志
   ↓
定位接口和 SQL
   ↓
SHOW ENGINE INNODB STATUS
   ↓
分析事务和锁等待
   ↓
检查索引与执行计划
   ↓
确定优化方案

4. 怎么解决死锁?

统一加锁顺序
+
优化 SQL 和索引
+
缩短事务执行时间
+
有限重试与幂等

5. InnoDB 会自动处理死锁吗?

默认开启死锁检测,检测到后通常回滚其中一个事务。

6. RC 会发生死锁吗?

会,RC 下仍然可能存在行锁循环等待。

7. 有索引还会死锁吗?

会,主键索引也不能完全避免死锁。

8. Java 怎么处理死锁?

识别死锁异常,在新的事务中完整重试,限制次数并保证幂等。


🔗 十、关联知识点

今天的 MySQL 死锁与以下知识有关:

  • MySQL锁机制.md:行锁、排他锁、Gap Lock、Next-Key Lock。
  • MVCC.md:快照读、当前读、事务隔离级别。
  • MySQL索引.md:索引结构与索引使用。
  • MySQL Explain.md:SQL 执行计划分析。

这些知识点可以结合起来准备面试。


⭐ 最终必背总结

MySQL 死锁的本质是多个事务形成循环锁等待。

线上排查时,我会先通过应用日志定位异常 SQL,再通过 SHOW ENGINE INNODB STATUS 分析事务、锁等待关系和索引情况。

解决时优先统一加锁顺序、优化 SQL 和索引、缩短事务执行时间。

InnoDB 默认开启死锁检测,检测到后通常会回滚一个事务。对于适合重试的业务,应用层还需要设计有限次数的事务重试,并保证幂等性。

这段回答是今天最需要熟练掌握的内容。


评论