1. MVCC的实现原理是什么?undo log版本链和ReadView如何配合?
2. RC和RR隔离级别下ReadView的区别?
3. Record Lock、Gap Lock、Next-Key Lock分别锁什么?什么时候触发?
4. 如何分析死锁?给出一个真实的死锁案例和解决方案?
5. 如何查看当前锁的持有和等待情况?
MVCC(Multi-Version Concurrency Control)让读操作不加锁,通过版本链实现非锁定读。
每行数据有两个隐藏字段:
DB_TRX_ID:最后修改该行的事务ID(6字节)
DB_ROLL_PTR:回滚指针,指向undo log中的上一版本(7字节)
示例:
id=1, name='张三', age=25, DB_TRX_ID=100, DB_ROLL_PTR=0x7F3A
每次UPDATE都会在undo log中保存旧版本,通过DB_ROLL_PTR形成链表:
当前行: id=1, name='王五', DB_TRX_ID=300, DB_ROLL_PTR →
版本2: id=1, name='李四', DB_TRX_ID=200, DB_ROLL_PTR →
版本1: id=1, name='张三', DB_TRX_ID=100, DB_ROLL_PTR=NULL
ReadView是事务在某个时刻生成的一个"可见性判断快照",包含4个关键字段:
creator_trx_id:创建该ReadView的事务ID
m_ids:生成ReadView时,当前所有活跃(未提交)事务的ID列表
min_trx_id:m_ids中最小的事务ID
max_trx_id:下一个将要分配的事务ID(当前最大事务ID + 1)
可见性判断规则:
对于版本链中某个版本的 DB_TRX_ID:
1. DB_TRX_ID == creator_trx_id
→ 自己的修改,可见 ✓
2. DB_TRX_ID < min_trx_id
→ 事务在生成ReadView前已提交,可见 ✓
3. DB_TRX_ID >= max_trx_id
→ 事务在生成ReadView后才开启,不可见 ✗
4. min_trx_id <= DB_TRX_ID < max_trx_id
→ 检查 DB_TRX_ID 是否在 m_ids 中
在 m_ids 中:事务未提交,不可见 ✗
不在 m_ids 中:事务已提交,可见 ✓
流程图:
遍历版本链(从最新版本开始)
↓
判断当前版本是否可见
↓ 可见 → 返回该版本数据
↓ 不可见 → 沿DB_ROLL_PTR找上一个版本
↓
重复判断,直到找到可见版本或到链尾
RC(Read Committed):
每次SELECT都生成新的ReadView
→ 能看到其他事务已提交的最新数据
→ 不可重复读
RR(Repeatable Read):
第一次SELECT生成ReadView,后续SELECT复用
→ 只能看到第一次查询时已提交的数据
→ 可重复读
示例对比:
时间线:
t1: 事务A(trx_id=100)BEGIN
t2: 事务B(trx_id=200)BEGIN
t3: 事务B UPDATE user SET name='李四' WHERE id=1
t4: 事务B COMMIT
t5: 事务A SELECT name FROM user WHERE id=1
RC隔离级别(t5生成新ReadView):
m_ids = [](事务B已提交)
→ 版本链最新 DB_TRX_ID=200 < max_trx_id
→ 200 不在 m_ids 中
→ 可见,返回 '李四'
RR隔离级别(t1时生成ReadView,t5复用):
m_ids = [100, 200](事务B未提交时的快照)
→ 版本链最新 DB_TRX_ID=200
→ 200 在 m_ids 中
→ 不可见,继续找上一个版本
→ 返回 '张三'
Global Lock(全局锁)
└─ FLUSH TABLES WITH READ LOCK
Table Lock(表级锁)
├─ 表锁:LOCK TABLES ... READ/WRITE
├─ 元数据锁(MDL):自动加,防DDL冲突
└─ 意向锁:IS/IX,快速判断表是否有行锁
Record Lock(行级锁)
├─ Record Lock:锁定索引上的单条记录
├─ Gap Lock:锁定索引记录之间的间隙
└─ Next-Key Lock:Record Lock + Gap Lock(左开右闭)
-- 锁定id=5这条记录
SELECT * FROM user WHERE id = 5 FOR UPDATE;
-- 命中唯一索引时,只加Record Lock
-- 其他事务无法修改或删除id=5这条记录
-- 假设user表id有记录:1, 5, 10
-- 以下查询会加Gap Lock,锁定 (5, 10) 之间的间隙
SELECT * FROM user WHERE id > 5 AND id < 10 FOR UPDATE;
-- 其他事务无法插入 id=6,7,8,9
-- 但可以修改 id=5 和 id=10
关键:Gap Lock之间不互斥,Gap Lock与Gap Lock可以共存。
Next-Key Lock = Record Lock + Gap Lock
左开右闭区间:(previous_record, current_record]
假设索引值有:1, 5, 10, 15
对 id=5 加 Next-Key Lock,锁定区间 (1, 5]
对 id=10 加 Next-Key Lock,锁定区间 (5, 10]
Next-Key Lock触发条件(RR隔离级别):
-- 1. 使用非唯一索引的等值查询
SELECT * FROM user WHERE idx_age = 25 FOR UPDATE;
-- 加锁:idx_age的Next-Key Lock (20, 25] + Gap Lock (25, 30)
-- 加锁:主键的Record Lock
-- 2. 范围查询
SELECT * FROM user WHERE id > 5 FOR UPDATE;
-- 加锁:Next-Key Lock (5, 10], (10, 15], (15, +∞)
-- 3. 无索引的查询(全表扫描,所有记录加Next-Key Lock)
SELECT * FROM user WHERE name = '张三' FOR UPDATE;
-- 如果name没有索引,所有记录和间隙都被锁住!
-- MySQL 8.0+ 查看锁等待
SELECT * FROM performance_schema.data_lock_waits;
-- 查看当前持有的锁
SELECT * FROM performance_schema.data_locks;
-- 查看InnoDB锁状态
SHOW ENGINE INNODB STATUS;
-- 锁等待超时设置
SHOW VARIABLES LIKE 'innodb_lock_wait_timeout';
-- 默认50秒,生产建议10-30秒
表结构和数据:
CREATE TABLE `order_item` (
`id` bigint NOT NULL AUTO_INCREMENT,
`order_id` bigint NOT NULL,
`product_id` bigint NOT NULL,
`quantity` int DEFAULT 1,
PRIMARY KEY (`id`),
KEY `idx_order` (`order_id`),
KEY `idx_product` (`product_id`)
) ENGINE=InnoDB;
-- 数据
INSERT INTO order_item VALUES (1, 100, 200, 1), (2, 100, 201, 2),
(3, 101, 200, 3), (4, 101, 201, 1);
死锁场景:
事务A 事务B
──────────────────────────────────────────
BEGIN;
BEGIN;
UPDATE order_item
SET quantity=5
WHERE order_id=100
AND product_id=200;
-- 锁住 idx_order 的记录
UPDATE order_item
SET quantity=3
WHERE order_id=101
AND product_id=201;
-- 锁住 idx_order 的记录
UPDATE order_item
SET quantity=8
WHERE order_id=101
AND product_id=201;
-- 等待事务B释放锁...
-- ↓ 同时 ↓
UPDATE order_item
SET quantity=10
WHERE order_id=100
AND product_id=200;
-- 等待事务A释放锁...
-- → 死锁!
SHOW ENGINE INNODB STATUS 输出:
------------------------
LATEST DETECTED DEADLOCK
------------------------
2026-05-31 10:30:00 0x7f8a3c0b6700
*** (1) TRANSACTION:
TRANSACTION 12345, ACTIVE 3 sec starting index read
mysql tables in use 1, locked 1
LOCK WAIT 2 lock struct(s), heap size 1136, 1 row lock(s)
MySQL thread id 10, OS thread handle 140228765456128, query id 500 localhost root updating
UPDATE order_item SET quantity=8 WHERE order_id=101 AND product_id=201
*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 58 page no 4 n bits 72 index idx_order of table `test`.`order_item`
trx id 12345 lock_mode X locks rec but not gap waiting
*** (2) TRANSACTION:
TRANSACTION 12346, ACTIVE 2 sec starting index read
mysql tables in use 1, locked 1
3 lock struct(s), heap size 1136, 2 row lock(s)
MySQL thread id 11, OS thread handle 140228764789504, query id 501 localhost root updating
UPDATE order_item SET quantity=10 WHERE order_id=100 AND product_id=200
*** (2) HOLDS THE LOCK(S):
RECORD LOCKS space id 58 page no 4 n bits 72 index idx_order of table `test`.`order_item`
trx id 12346 lock_mode X locks rec but not gap
*** (2) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 58 page no 4 n bits 72 index idx_order of table `test`.`order_item`
trx id 12346 lock_mode X locks rec but not gap waiting
*** WE ROLL BACK TRANSACTION (1)
方案1:按固定顺序加锁
@Service
public class OrderItemService {
/**
* 固定按id升序更新,避免交叉锁
*/
@Transactional
public void updateOrderItems(List<Long> itemIds, Map<Long, Integer> quantityMap) {
// 按id排序,确保加锁顺序一致
List<Long> sortedIds = itemIds.stream()
.sorted()
.collect(Collectors.toList());
for (Long id : sortedIds) {
OrderItem item = orderItemMapper.selectById(id);
item.setQuantity(quantityMap.get(id));
orderItemMapper.updateById(item);
}
}
}
方案2:缩小事务范围
/**
* 将大事务拆分为小事务,减少锁持有时间
*/
public void batchUpdate(List<OrderItem> items) {
items.stream()
.sorted(Comparator.comparing(OrderItem::getId))
.forEach(item -> {
// 每条记录一个独立事务
transactionTemplate.execute(status -> {
orderItemMapper.updateById(item);
return null;
});
});
}
方案3:降低隔离级别
-- 如果业务允许,使用RC隔离级别
-- RC下不会加Gap Lock,减少死锁概率
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
方案4:死锁检测与重试
@Service
@Slf4j
public class DeadlockRetryService {
private static final int MAX_RETRY = 3;
@Transactional
public void updateWithRetry(Long orderId, Long productId, int quantity) {
updateOrderItem(orderId, productId, quantity);
}
public void executeWithRetry(Long orderId, Long productId, int quantity) {
int retryCount = 0;
while (retryCount < MAX_RETRY) {
try {
updateWithRetry(orderId, productId, quantity);
return;
} catch (CannotAcquireLockException | DeadlockLoserDataAccessException e) {
retryCount++;
log.warn("死锁重试,第{}次, orderId={}", retryCount, orderId);
if (retryCount >= MAX_RETRY) {
throw new RuntimeException("死锁重试次数耗尽", e);
}
try {
Thread.sleep(100 * retryCount); // 退避策略
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException("线程被中断", ie);
}
}
}
}
}
-- 1. 确保查询走索引,避免锁住全表
EXPLAIN SELECT * FROM user WHERE name = '张三' FOR UPDATE;
-- type=ALL → 全表扫描,所有行加锁
-- type=ref → 走索引,只锁匹配行
-- 2. RC隔离级别减少Gap Lock
SET GLOBAL transaction_isolation = 'READ-COMMITTED';
-- 3. 合理使用索引避免Next-Key Lock退化
-- 非唯一索引 → Next-Key Lock
-- 唯一索引 → Record Lock(等值查询命中时)
-- 4. 控制并发度
SET GLOBAL innodb_lock_wait_timeout = 10;
-- 5. 监控锁等待
-- 锁等待超过阈值告警
SELECT * FROM sys.innodb_lock_waits;
答:
在RR隔离级别下,MVCC的快照读(普通SELECT)通过ReadView避免了幻读。但当前读(SELECT FOR UPDATE、UPDATE、DELETE等)需要加锁。InnoDB通过Next-Key Lock在当前读时锁住间隙,防止其他事务插入新数据,从而解决幻读。所以RR下防止幻读是MVCC + Next-Key Lock共同作用的结果。
答:
ReadView在第一次执行快照读(普通SELECT)时才生成,而不是BEGIN时。这是因为有些事务只做写操作,不需要ReadView,延迟生成可以减少开销。这也是为什么在RR下,BEGIN后先UPDATE再SELECT,SELECT能看到其他已提交事务的数据,因为UPDATE是当前读不影响ReadView,SELECT时才生成快照。
答:
1. 非唯一索引的范围查询会加大量Gap Lock
2. 没有索引的查询会导致全表Next-Key Lock
3. Gap Lock不互斥但会阻止INSERT,高并发插入场景影响大
4. 降低到RC隔离级别可以消除Gap Lock,但需要评估是否允许幻读
答:
1. SHOW ENGINE INNODB STATUS 查看最近一次死锁信息
2. 开启死锁日志:SET GLOBAL innodb_print_all_deadlocks = ON
3. 分析死锁日志中两个事务的SQL和锁等待关系
4. 画出锁的持有和等待图(wait-for graph)
5. 常见原因:交叉更新、间隙锁冲突、索引未命中导致锁升级
答:
MDL(Metadata Lock)是MySQL自动加的表级元数据锁。DML操作加MDL读锁,DDL操作需要MDL写锁。当有长事务持有MDL读锁时,DDL会被阻塞,后续所有DML也会被阻塞(等DDL释放MDL写锁)。解决方案:设置 lock_wait_timeout,DDL超时自动失败;使用 pt-online-schema-change 做在线DDL;在低峰期执行DDL。
-- 两个终端模拟
-- 终端1: BEGIN; UPDATE user SET name='李四' WHERE id=1; (不COMMIT)
-- 终端2: SELECT * FROM user WHERE id=1; (能看到什么?)
-- 终端2: BEGIN; SELECT * FROM user WHERE id=1; (RR下能看到什么?)
-- 终端1: COMMIT;
-- 终端2: SELECT * FROM user WHERE id=1; (能看到什么?为什么?)
-- 1. 创建测试表,插入两条数据
-- 2. 终端1: BEGIN; UPDATE t SET val=1 WHERE id=1;
-- 3. 终端2: BEGIN; UPDATE t SET val=2 WHERE id=2;
-- 4. 终端1: UPDATE t SET val=3 WHERE id=2; (等待)
-- 5. 终端2: UPDATE t SET val=4 WHERE id=1; (死锁!)
-- 6. 执行 SHOW ENGINE INNODB STATUS 分析死锁日志
-- 1. 在没有索引的字段上执行 FOR UPDATE,观察锁范围
-- 2. 加索引后重复,对比锁范围变化
-- 3. 分别在RC和RR下执行范围查询,对比Gap Lock差异
-- 4. 使用 performance_schema.data_locks 查看锁详情
| 知识点 | 关键内容 |
|---|---|
| MVCC | 隐藏字段、undo log版本链、ReadView四字段、可见性规则 |
| RC vs RR | RC每次SELECT生成ReadView,RR复用第一次的ReadView |
| Record Lock | 锁定索引记录,唯一索引等值查询命中时 |
| Gap Lock | 锁定间隙,防止幻读插入,RC下不存在 |
| Next-Key Lock | Record + Gap,RR下非唯一索引的默认加锁方式 |
| 死锁 | 交叉锁、排序加锁、缩小事务、重试机制 |