← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识面试模拟实操练习本节小结

P2-03 - MySQL进阶-MVCC与锁

本节目标(学完能回答的面试题)

1. MVCC的实现原理是什么?undo log版本链和ReadView如何配合?

2. RC和RR隔离级别下ReadView的区别?

3. Record Lock、Gap Lock、Next-Key Lock分别锁什么?什么时候触发?

4. 如何分析死锁?给出一个真实的死锁案例和解决方案?

5. 如何查看当前锁的持有和等待情况?

核心知识

一、MVCC实现原理

MVCC(Multi-Version Concurrency Control)让读操作不加锁,通过版本链实现非锁定读。

1.1 隐藏字段

每行数据有两个隐藏字段:


DB_TRX_ID:最后修改该行的事务ID(6字节)
DB_ROLL_PTR:回滚指针,指向undo log中的上一版本(7字节)

示例:


id=1, name='张三', age=25, DB_TRX_ID=100, DB_ROLL_PTR=0x7F3A

1.2 Undo Log版本链


每次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

1.3 ReadView机制(核心)

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找上一个版本
  ↓
  重复判断,直到找到可见版本或到链尾

1.4 RC vs RR 的ReadView差异


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 中
  → 不可见,继续找上一个版本
  → 返回 '张三'

二、InnoDB锁类型

2.1 锁类型总览


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(左开右闭)

2.2 Record Lock(记录锁)


-- 锁定id=5这条记录
SELECT * FROM user WHERE id = 5 FOR UPDATE;

-- 命中唯一索引时,只加Record Lock
-- 其他事务无法修改或删除id=5这条记录

2.3 Gap Lock(间隙锁)


-- 假设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可以共存。

2.4 Next-Key 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没有索引,所有记录和间隙都被锁住!

2.5 锁的查看


-- 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秒

三、死锁分析与解决

3.1 死锁真实案例

表结构和数据:


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)

3.2 死锁解决方案

方案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;

面试模拟

Q1:MVCC能解决幻读吗?

答:

在RR隔离级别下,MVCC的快照读(普通SELECT)通过ReadView避免了幻读。但当前读(SELECT FOR UPDATE、UPDATE、DELETE等)需要加锁。InnoDB通过Next-Key Lock在当前读时锁住间隙,防止其他事务插入新数据,从而解决幻读。所以RR下防止幻读是MVCC + Next-Key Lock共同作用的结果。

Q2:为什么RR级别第一次SELECT后才生成ReadView?

答:

ReadView在第一次执行快照读(普通SELECT)时才生成,而不是BEGIN时。这是因为有些事务只做写操作,不需要ReadView,延迟生成可以减少开销。这也是为什么在RR下,BEGIN后先UPDATE再SELECT,SELECT能看到其他已提交事务的数据,因为UPDATE是当前读不影响ReadView,SELECT时才生成快照。

Q3:Gap Lock在什么场景下会导致性能问题?

答:

1. 非唯一索引的范围查询会加大量Gap Lock

2. 没有索引的查询会导致全表Next-Key Lock

3. Gap Lock不互斥但会阻止INSERT,高并发插入场景影响大

4. 降低到RC隔离级别可以消除Gap Lock,但需要评估是否允许幻读

Q4:如何排查线上死锁?

答:

1. SHOW ENGINE INNODB STATUS 查看最近一次死锁信息

2. 开启死锁日志:SET GLOBAL innodb_print_all_deadlocks = ON

3. 分析死锁日志中两个事务的SQL和锁等待关系

4. 画出锁的持有和等待图(wait-for graph)

5. 常见原因:交叉更新、间隙锁冲突、索引未命中导致锁升级

Q5:MDL锁是什么?DDL和DML冲突怎么处理?

答:

MDL(Metadata Lock)是MySQL自动加的表级元数据锁。DML操作加MDL读锁,DDL操作需要MDL写锁。当有长事务持有MDL读锁时,DDL会被阻塞,后续所有DML也会被阻塞(等DDL释放MDL写锁)。解决方案:设置 lock_wait_timeout,DDL超时自动失败;使用 pt-online-schema-change 做在线DDL;在低峰期执行DDL。

实操练习

练习1:验证MVCC可见性


-- 两个终端模拟
-- 终端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; (能看到什么?为什么?)

练习2:复现死锁


-- 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 分析死锁日志

练习3:锁优化实验


-- 1. 在没有索引的字段上执行 FOR UPDATE,观察锁范围
-- 2. 加索引后重复,对比锁范围变化
-- 3. 分别在RC和RR下执行范围查询,对比Gap Lock差异
-- 4. 使用 performance_schema.data_locks 查看锁详情

本节小结

知识点关键内容
MVCC隐藏字段、undo log版本链、ReadView四字段、可见性规则
RC vs RRRC每次SELECT生成ReadView,RR复用第一次的ReadView
Record Lock锁定索引记录,唯一索引等值查询命中时
Gap Lock锁定间隙,防止幻读插入,RC下不存在
Next-Key LockRecord + Gap,RR下非唯一索引的默认加锁方式
死锁交叉锁、排序加锁、缩小事务、重试机制