← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L17 - MySQL事务与MVCC

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

核心知识(1小时精讲内容)

一、事务ACID与实现机制


┌──────────────────────────────────────────────────┐
│                 ACID四大特性                       │
├──────────┬───────────────────────────────────────┤
│ 原子性(A) │ undo log(回滚日志)                     │
│          │ 事务失败→根据undo log回滚              │
├──────────┼───────────────────────────────────────┤
│ 一致性(C) │ 其他三个特性共同保证                    │
│          │ + 业务约束(唯一键/外键/触发器)          │
├──────────┼───────────────────────────────────────┤
│ 隔离性(I) │ MVCC(多版本并发控制) + 锁              │
│          │ 读写不冲突(MVCC) + 写写互斥(锁)         │
├──────────┼───────────────────────────────────────┤
│ 持久性(D) │ redo log(WAL, 先写日志再写磁盘)        │
│          │ 崩溃恢复时重放redo log                  │
└──────────┴───────────────────────────────────────┘

redo log vs undo log:
┌──────────┬─────────────────────────────────────┐
│ redo log │ 记录"物理修改"(某页某偏移写了什么)    │
│          │ 用途: 崩溃恢复(持久性)                │
│          │ 特点: 顺序写, 固定大小循环写           │
├──────────┼─────────────────────────────────────┤
│ undo log │ 记录"逻辑反向操作"(INSERT→DELETE)    │
│          │ 用途: 事务回滚(原子性) + MVCC版本链   │
│          │ 特点: 随事务产生, 事务提交后不一定删除 │
└──────────┴─────────────────────────────────────┘

二、四种隔离级别


┌───────────────────┬──────┬──────────┬──────┬───────────────────┐
│ 隔离级别            │ 脏读 │ 不可重复读 │ 幻读 │ 实现方式           │
├───────────────────┼──────┼──────────┼──────┼───────────────────┤
│ READ UNCOMMITTED  │  ✅  │   ✅     │  ✅  │ 无隔离             │
│ (读未提交)         │      │          │      │                   │
├───────────────────┼──────┼──────────┼──────┼───────────────────┤
│ READ COMMITTED    │  ❌  │   ✅     │  ✅  │ MVCC(每次SELECT    │
│ (读已提交,RC)      │      │          │      │ 生成新ReadView)    │
├───────────────────┼──────┼──────────┼──────┼───────────────────┤
│ REPEATABLE READ   │  ❌  │   ❌     │  ❌* │ MVCC(首次SELECT    │
│ (可重复读,RR)默认  │      │          │      │ 生成ReadView复用)  │
│                   │      │          │      │ + Gap Lock防幻读   │
├───────────────────┼──────┼──────────┼──────┼───────────────────┤
│ SERIALIZABLE      │  ❌  │   ❌     │  ❌  │ 表级锁             │
│ (串行化)          │      │          │      │                   │
└───────────────────┴──────┴──────────┴──────┴───────────────────┘

*MySQL InnoDB在RR级别通过Gap Lock + Next-Key Lock解决幻读

三种并发问题:
脏读: 事务A读到事务B未提交的数据 → B回滚后A读到的是脏数据
不可重复读: 事务A两次读同一行,中间B修改并提交 → 两次结果不同
幻读: 事务A两次范围查询,中间B插入新行 → 第二次多了行(幻影)

三、MVCC实现原理

3.1 隐藏列


每行记录的隐藏列:
┌──────────────────────────────────────────────────────────┐
│ DB_TRX_ID(6B)  |  DB_ROLL_PTR(7B)  |  DB_ROW_ID(6B)    │
│ 最近修改的事务ID  |  指向undo log的指针 │ 隐藏主键(无PK时) │
└──────────────────────────────────────────────────────────┘

3.2 Undo Log版本链


                    ┌─────────────────┐
                    │ 当前数据行        │
                    │ trx_id = 103     │
                    │ roll_ptr ────────┼────→ ┌──────────────┐
                    │ name = "张三"     │      │ Undo Log v2  │
                    └─────────────────┘      │ trx_id = 102  │
                                             │ name = "李四"  │
                                             │ roll_ptr ─────┼────→ ┌──────────────┐
                                             └──────────────┘      │ Undo Log v1  │
                                                                   │ trx_id = 100  │
                                                                   │ name = "王五"  │
                                                                   └──────────────┘

每修改一次产生一个undo log版本,通过roll_ptr串成版本链
MVCC通过遍历版本链 + ReadView判断哪个版本对当前事务可见

3.3 ReadView


ReadView四个核心字段:
┌──────────────────────────────────────────────────┐
│ m_ids        = [101, 102, 103]                    │
│   生成ReadView时,所有活跃(未提交)的事务ID列表     │
│                                                   │
│ min_trx_id   = 101                                │
│   m_ids中的最小值                                 │
│                                                   │
│ max_trx_id   = 104                                │
│   下一个即将分配的事务ID(当前最大事务ID+1)          │
│                                                   │
│ creator_trx_id = 100                              │
│   创建该ReadView的事务ID                          │
└──────────────────────────────────────────────────┘

可见性判断规则(对数据行版本的trx_id):
┌───────────────────────────────────────────────┐
│ trx_id == creator_trx_id?                     │
│   是 → 可见(自己的修改)             ✅         │
│                                               │
│ trx_id < min_trx_id?                          │
│   是 → 可见(在ReadView创建前已提交)  ✅         │
│                                               │
│ trx_id >= max_trx_id?                         │
│   是 → 不可见(在ReadView创建后开启)  ❌         │
│                                               │
│ min_trx_id <= trx_id < max_trx_id?            │
│   在m_ids中 → 不可见(事务未提交)    ❌         │
│   不在m_ids中 → 可见(事务已提交)    ✅         │
└───────────────────────────────────────────────┘

遍历过程:
1. 从版本链最新版本开始
2. 判断trx_id是否可见
3. 可见 → 返回该版本数据
4. 不可见 → 沿roll_ptr找上一个版本继续判断
5. 直到找到可见版本或返回空

四、RC vs RR 的ReadView区别


RC(读已提交):
┌────────────────────────────────────────┐
│ BEGIN;                                 │
│ SELECT ... → 生成ReadView1             │
│   → 看到的是此刻已提交的数据            │
│                                        │
│ (其他事务提交了修改)                    │
│                                        │
│ SELECT ... → 生成ReadView2 (新的!)     │
│   → 能看到其他事务已提交的最新数据       │
│   → 不可重复读!                        │
└────────────────────────────────────────┘

RR(可重复读) — MySQL默认:
┌────────────────────────────────────────┐
│ BEGIN;                                 │
│ SELECT ... → 生成ReadView1             │
│   → 看到的是此刻已提交的数据            │
│                                        │
│ (其他事务提交了修改)                    │
│                                        │
│ SELECT ... → 还是ReadView1 (复用!)     │
│   → 看到的和第一次一样                  │
│   → 可重复读!                          │
└────────────────────────────────────────┘

核心区别:
RC: 每次SELECT生成新ReadView → 能看到最新提交 → 不可重复读
RR: 第一次SELECT生成ReadView,后续复用 → 看到一致的快照 → 可重复读

五、快照读 vs 当前读


快照读(普通SELECT) — 使用MVCC:
  SELECT * FROM user WHERE id = 1;
  → 不加锁,读历史版本(ReadView决定)

当前读(加锁读) — 使用锁:
  SELECT * FROM user WHERE id = 1 FOR UPDATE;  ← 排他锁(X)
  SELECT * FROM user WHERE id = 1 LOCK IN SHARE MODE; ← 共享锁(S)
  UPDATE user SET name = '新' WHERE id = 1;   ← 排他锁
  DELETE FROM user WHERE id = 1;              ← 排他锁
  INSERT INTO user VALUES(...);               ← 插入意向锁
  → 读取最新已提交数据 + 加锁

为什么当前读能看到最新数据?
当前读不走MVCC,直接读最新版本(不加锁的SELECT才走MVCC)

六、InnoDB锁详解

6.1 锁体系


┌─────────────────────────────────────────────────────────┐
│                  InnoDB锁体系                            │
├─────────────────┬───────────────────────────────────────┤
│    全局锁        │  FLUSH TABLES WITH READ LOCK          │
│    (备份用)      │  整库只读                             │
├─────────────────┼───────────────────────────────────────┤
│    表级锁        │  表锁 / 元数据锁(MDL) / 意向锁(IS/IX) │
│                 │  AUTO-INC锁                            │
├─────────────────┼───────────────────────────────────────┤
│    行级锁        │  Record Lock: 锁定索引记录             │
│  (InnoDB特有)   │  Gap Lock: 锁定索引间隙(不含记录)      │
│                 │  Next-Key Lock: Record + Gap           │
│                 │  Insert Intention: 插入意向锁          │
└─────────────────┴───────────────────────────────────────┘

意向锁(IS/IX):
  表级标记,快速判断表中是否有行锁
  如: 事务A在某行加了X锁 → 表自动加IX锁
  事务B要加表锁 → 检查IX锁冲突 → 不用逐行检查

6.2 Gap Lock与Next-Key Lock


Record Lock:  锁定一行索引记录
Gap Lock:     锁定索引间隙(两个记录之间的空隙),不含记录本身
Next-Key Lock: Record Lock + Gap Lock (左开右闭区间)

RR级别下InnoDB的默认行锁算法是Next-Key Lock

示例: 表t有数据 id=5, 10, 15, 20
索引中的间隙: (-∞,5), (5,10), (10,15), (15,20), (20,+∞)

SELECT * FROM t WHERE id = 10 FOR UPDATE;
加锁: (5,10] Next-Key Lock + (10,15) Gap Lock
→ 锁住id=10这一行 + id在(5,15)范围内的间隙
→ 防止其他事务在(5,15)范围内插入新行 → 防幻读

6.3 Next-Key Lock加锁规则(RR级别)


原则1: 加锁的基本单位是Next-Key Lock(左开右闭)
原则2: 查找过程中访问到的对象才会加锁
优化1: 等值查询,唯一索引,Next-Key Lock退化为Record Lock
优化2: 等值查询,向右遍历到最后一个不满足条件的值,退化为Gap Lock

示例表: t(id PK, c 普通索引, d)
数据: (5,5,5), (10,10,10), (15,15,15), (20,20,20)

场景1: SELECT * FROM t WHERE c = 10 FOR UPDATE;
加锁: (5,10] Next-Key Lock + (10,15) Gap Lock
→ c=10这一行 + c在(5,15)的间隙

场景2: SELECT * FROM t WHERE c >= 10 AND c < 12 FOR UPDATE;
加锁: (5,10] + (10,15] + (15,20) 三个Next-Key Lock
→ 因为c=15也被扫描到了

七、RR级别如何解决幻读


MVCC解决快照读的幻读:
  事务A第一次SELECT → 生成ReadView
  事务B INSERT新行 → 事务A第二次SELECT → 还是同一个ReadView
  → 看不到新插入的行 → 无幻读

锁解决当前读的幻读:
  事务A: SELECT * FROM t WHERE c = 10 FOR UPDATE;
  → 加了(5,10] Next-Key Lock + (10,15) Gap Lock
  事务B: INSERT INTO t VALUES(12, 12, 12); → 被Gap Lock阻塞
  → 事务A再次SELECT → 不会多出行 → 无幻读

特殊情况(RR级别仍然可能幻读):
  事务A: SELECT * FROM t WHERE c = 10;  (快照读,无幻读)
  事务A: UPDATE t SET d = 100 WHERE c = 10;  (当前读,更新了所有c=10的行)
  → 如果事务B在中间插入了c=10的行
  → 事务A的UPDATE会"看到"这行(当前读)并更新
  → 事务A再SELECT → 突然多了一行d=100的新行 → 幻读!

结论: MySQL RR级别"基本"解决幻读,但快照读和当前读混用时有例外

八、死锁检测与处理


死锁条件检测: innodb_deadlock_detect=ON(默认)
超时回滚: innodb_lock_wait_timeout=50s(默认)

常见死锁场景:
场景1: AB-BA死锁
  线程1: UPDATE t SET val=1 WHERE id=1; → UPDATE t SET val=2 WHERE id=2;
  线程2: UPDATE t SET val=3 WHERE id=2; → UPDATE t SET val=4 WHERE id=1;
  解决: 保证所有事务按相同顺序访问行(如按id升序)

场景2: Gap Lock死锁(RR级别特有)
  线程1: SELECT * FROM t WHERE id=5 FOR UPDATE; → Gap Lock (5,10)
  线程2: SELECT * FROM t WHERE id=8 FOR UPDATE; → Gap Lock (5,10)
  线程1: INSERT INTO t VALUES(6); → 等待线程2的Gap Lock
  线程2: INSERT INTO t VALUES(7); → 等待线程1的Gap Lock → DEADLOCK
  解决: RC级别不会产生Gap Lock,或改用唯一索引查询

排查命令:
  SHOW ENGINE INNODB STATUS\G    -- 最近死锁信息
  SELECT * FROM information_schema.INNODB_TRX;    -- 当前事务

面试话术: "MySQL默认RR隔离级别,通过MVCC+锁解决并发问题。MVCC依赖undo log版本链和ReadView:版本链保存数据历史版本,ReadView的四个字段(m_ids/min_trx_id/max_trx_id/creator_trx_id)判断哪个版本对当前事务可见。RC每次SELECT生成新ReadView所以不可重复读,RR只在第一次SELECT生成然后复用所以可重复读。快照读走MVCC不加锁,当前读(FOR UPDATE/UPDATE/DELETE)加锁读最新数据。RR级别下InnoDB默认用Next-Key Lock(Record+Gap)防止幻读。"

面试速记卡(考前30秒速看)

练习题(自测)

1. 事务A(trx_id=100)在RR级别下执行SELECT,此时活跃事务为[98,99,100,101]。请判断trx_id=95/98/100/102的数据版本对事务A是否可见。

2. RC和RR隔离级别下,事务A执行两次相同的SELECT,中间事务B提交了修改。两次SELECT的结果分别是什么?为什么?

3. 为什么当前读(FOR UPDATE)能看到最新数据,而快照读看不到?它们的实现机制有什么不同?

4. 表t有数据id=5,10,15。RR级别下执行SELECT * FROM t WHERE id > 8 FOR UPDATE,会加哪些锁?

5. 说明一个RR级别下仍然可能出现幻读的场景,并解释原因。

学习资料