┌──────────────────────────────────────────────────┐
│ 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插入新行 → 第二次多了行(幻影)
每行记录的隐藏列:
┌──────────────────────────────────────────────────────────┐
│ DB_TRX_ID(6B) | DB_ROLL_PTR(7B) | DB_ROW_ID(6B) │
│ 最近修改的事务ID | 指向undo log的指针 │ 隐藏主键(无PK时) │
└──────────────────────────────────────────────────────────┘
┌─────────────────┐
│ 当前数据行 │
│ 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判断哪个版本对当前事务可见
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(读已提交):
┌────────────────────────────────────────┐
│ BEGIN; │
│ SELECT ... → 生成ReadView1 │
│ → 看到的是此刻已提交的数据 │
│ │
│ (其他事务提交了修改) │
│ │
│ SELECT ... → 生成ReadView2 (新的!) │
│ → 能看到其他事务已提交的最新数据 │
│ → 不可重复读! │
└────────────────────────────────────────┘
RR(可重复读) — MySQL默认:
┌────────────────────────────────────────┐
│ BEGIN; │
│ SELECT ... → 生成ReadView1 │
│ → 看到的是此刻已提交的数据 │
│ │
│ (其他事务提交了修改) │
│ │
│ SELECT ... → 还是ReadView1 (复用!) │
│ → 看到的和第一次一样 │
│ → 可重复读! │
└────────────────────────────────────────┘
核心区别:
RC: 每次SELECT生成新ReadView → 能看到最新提交 → 不可重复读
RR: 第一次SELECT生成ReadView,后续复用 → 看到一致的快照 → 可重复读
快照读(普通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锁体系 │
├─────────────────┬───────────────────────────────────────┤
│ 全局锁 │ 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锁冲突 → 不用逐行检查
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)范围内插入新行 → 防幻读
原则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也被扫描到了
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)防止幻读。"
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级别下仍然可能出现幻读的场景,并解释原因。