知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# MySQL 事务与 MVCC:从 ACID 到可重复读 > 导读:理解事务为何需要 ACID、并发读写会遇到什么问题,以及 InnoDB 如何用 MVCC、Read View 与锁在一致性和并发之间取舍。 ## 一、先理解事务要解决什么 ### Q:事务为什么需要 ACID? A:事务把多步业务操作组织为一个可靠单元,原子性避免半完成状态,一致性是正确约束下的结果,隔离性处理并发影响,持久性确保提交后可恢复。 ``` A - 原子性(Atomicity):事务中的操作要么全部成功,要么全部失败回滚 实现:undo log(回滚日志) C - 一致性(Consistency):事务执行前后,数据库从一个一致状态变到另一个一致状态 实现:由其他三个特性共同保证 I - 隔离性(Isolation):并发事务之间互不干扰 实现:MVCC + 锁 D - 持久性(Durability):事务提交后,数据永久保存 实现:redo log(重做日志) ``` ### Q:为什么转账必须放在同一个事务中? A:扣款和入账必须同时成功或同时回滚;undo log 保存修改前值,为失败恢复提供基础。 ```sql -- 场景:用户 A 向用户 B 转账 100 元 BEGIN; UPDATE users SET balance = balance - 100 WHERE id = 1; -- A: 500 → 400 UPDATE users SET balance = balance + 100 WHERE id = 2; -- B: 300 → 400 COMMIT; -- 如果没有事务(原子性): -- 执行完第 1 步后,服务器宕机 -- A 的余额已经扣减(400),但 B 的余额没有增加(还是 300) -- 100 元凭空消失!数据不一致! -- 有了事务(原子性): -- 如果第 2 步失败,整个事务回滚 -- A 的余额恢复为 500,B 的余额保持 300,数据保持一致 -- undo log 如何实现回滚: -- 执行第 1 步时,undo log 记录:id=1 的 balance 旧值是 500 -- 执行第 2 步时,undo log 记录:id=2 的 balance 旧值是 300 -- 回滚时,按 undo log 逆序恢复 ```  ## 二、并发事务会带来哪些可见性问题 ### Q:脏读、不可重复读和幻读分别是什么? A:它们分别对应读到未提交修改、同一行前后结果改变和范围结果出现新增或减少的行。 ``` 脏读(Dirty Read): 事务 A 读到了事务 B 未提交的数据 事务 B 回滚后,A 读到的数据就是"脏"的 不可重复读(Non-Repeatable Read): 事务 A 两次读同一行,结果不同(因为事务 B 在中间修改并提交了) 针对的是同一行数据的修改(UPDATE) 幻读(Phantom Read): 事务 A 两次查询,第二次多了(或少了)几行(因为事务 B 插入/删除了数据) 针对的是数据行数的变化(INSERT/DELETE) ``` ### Q:这些问题在两个并发事务中如何发生? A:用时间线对照可看出:一个事务的写入或插入,会改变另一个事务在不同读语义下看到的结果。  *图:脏读、不可重复读、幻读三种并发异常* ``` 假设初始数据:users 表,id=1, balance=100 脏读示例: 事务A 事务B ───────────────────────────────────── BEGIN BEGIN UPDATE SET balance=50 (未提交) SELECT balance → 50 ❌ 脏读! ROLLBACK → balance=100 (事务B 读到的 50 是脏数据) 不可重复读示例: 事务A 事务B ───────────────────────────────────── BEGIN (RC级别) SELECT balance → 100 BEGIN UPDATE SET balance=50 COMMIT SELECT balance → 50 ← 同一次查询,两次结果不同! 幻读示例: 事务A 事务B ───────────────────────────────────── BEGIN SELECT COUNT(*) → 10 BEGIN INSERT INTO users VALUES (...) COMMIT SELECT COUNT(*) → 11 ← 多了 1 行!幻读! ```  ### Q:四种隔离级别如何在一致性和并发间取舍? A:隔离越强,异常越少但并发限制通常越多。InnoDB 默认 RR;具体默认值和行为需要结合数据库版本及读类型理解。  *图:四种隔离级别与 RR、RC 的核心区别* ``` 隔离级别 脏读 不可重复读 幻读 ───────────────────────────────────────────────── 读未提交(RU) ✓ ✓ ✓ 读已提交(RC) ✗ ✓ ✓ 可重复读(RR) ✗ ✗ ✓(InnoDB 通过间隙锁解决) 串行化(Serializable) ✗ ✗ ✗ MySQL InnoDB 默认:可重复读(RR) Oracle、PostgreSQL 默认:读已提交(RC) 隔离级别实现机制: RU(读未提交):不加锁,不生成 Read View,直接读最新版本 RC(读已提交):每次 SELECT 生成新 Read View,只能看到已提交的数据 RR(可重复读):第一次 SELECT 生成 Read View,整个事务复用 Serializable:所有 SELECT 隐式加 LOCK IN SHARE MODE,退化为串行执行 RR vs RC 核心区别: RC(读已提交) RR(可重复读) ┌─────────────────────────────────────────────────────────────────┐ │ Read View 每次 SELECT 重新生成 第一次 SELECT 生成 │ │ (刷新最新快照) 整个事务复用 │ │ │ │ 可见性 能看到其他事务已提交的修改 只能看到事务开始时的 │ │ 每次读可能不一样 快照,每次读一样 │ │ │ │ 间隙锁 不加间隙锁 加间隙锁(防幻读) │ │ │ │ 典型场景 只需避免脏读,允许不可重复读 需要事务内数据一致 │ │ 报表查询等 金融、库存扣减等 │ └─────────────────────────────────────────────────────────────────┘ ``` ## 三、MVCC 如何让普通读不阻塞写 ### Q:MVCC 是什么,它解决了什么问题? A:MVCC 通过历史版本和读视图让快照读选择一个可见版本,减少读写互相阻塞;它不替代当前读所需的锁。 MVCC 是 InnoDB 实现读已提交和可重复读的核心机制,让读操作不加锁,提高并发性能。 ### Q:MVCC 依赖哪些核心组件? A:记录隐藏字段标识最新修改和历史指针,undo log 保存旧版本,Read View 定义当前事务可见的版本边界。 **1. 隐藏字段**  *图:InnoDB 行记录的 trx_id 与 roll_pointer* ``` InnoDB 每行数据有两个隐藏字段: trx_id:最近一次修改该行的事务 ID roll_pointer:指向 undo log 中上一个版本的指针 ┌──────────────────────────────────────────────┐ │ id │ name │ trx_id │ roll_pointer │ │ 1 │ 张三 │ 100 │ → undo log │ └──────────────────────────────────────────────┘ ``` **2. undo log(版本链)** ``` 每次修改数据,旧版本会被记录到 undo log,形成版本链: 当前版本(trx_id=300):name='王五' ↓ roll_pointer 旧版本(trx_id=200):name='李四' ↓ roll_pointer 旧版本(trx_id=100):name='张三' ↓ roll_pointer null(最初版本) ``` **3. Read View(读视图)**  *图:Read View 四字段与可见性判断决策树* ``` Read View 是事务开始时(或第一次读时)生成的快照,记录: m_ids:当前活跃(未提交)的事务 ID 列表 min_trx_id:m_ids 中最小的事务 ID max_trx_id:下一个将要分配的事务 ID(当前最大 + 1) creator_trx_id:创建这个 Read View 的事务 ID 可见性判断规则: trx_id == creator_trx_id → 自己修改的,可见 trx_id < min_trx_id → 在 Read View 创建前已提交,可见 trx_id >= max_trx_id → 在 Read View 创建后才开始,不可见 min_trx_id <= trx_id < max_trx_id: trx_id 在 m_ids 中 → 还未提交,不可见 trx_id 不在 m_ids 中 → 已提交,可见 MVCC 可见性判断决策树: 当前行 trx_id │ ↓ ┌────────────┐ │ 是自己改的? │──Yes→ 可见 ✓(自己改的当然能看到) │ (==creator) │ └────┬───────┘ │ No ↓ ┌────────────────┐ │ trx_id < │──Yes→ 可见 ✓(在我开始前已提交,能看) │ min_trx_id? │ └────┬───────────┘ │ No ↓ ┌────────────────┐ │ trx_id >= │──Yes→ 不可见 ✗(在我开始后才创建,不该看) │ max_trx_id? │ 沿 roll_pointer 回溯上一个版本 └────┬───────────┘ │ No (trx_id 在 [min, max) 区间) ↓ ┌────────────────┐ │ trx_id 在 │──Yes→ 不可见 ✗(修改者还没提交,不能看脏数据) │ m_ids 中? │ 沿 roll_pointer 回溯上一个版本 └────┬───────────┘ │ No (已提交) ↓ 可见 ✓ 回溯过程:沿着 undo log 版本链,逐个版本判断,直到找到可见版本 ```  [编辑 Excalidraw 源图](/images/excalidraw/03-transaction-mvcc-mvcc-visibility-diagram.excalidraw)  [编辑 Excalidraw 源图](/images/excalidraw/03-transaction-mvcc-undo-version-chain-diagram.excalidraw) ### Q:同一场景下 RR 为什么能读到一致结果? A:RR 的快照读复用同一 Read View;当最新版本不可见时,沿 undo 版本链查找符合可见性规则的历史版本。 ### Q:两个事务交错执行时,版本链与 Read View 如何配合? A:以下时间线展示写事务创建新版本后,读事务如何根据自己已有视图回溯到可见版本。 ``` 初始数据:users 表,id=1, name='张三'(由 trx_id=50 的事务写入,已提交) 时间线(可重复读隔离级别): T1: 事务 A 开始(trx_id=100) 生成 Read View: m_ids = [100],min_trx_id = 100,max_trx_id = 101,creator_trx_id = 100 T2: 事务 B 开始(trx_id=200) 生成 Read View: m_ids = [100, 200],min_trx_id = 100,max_trx_id = 201 T3: 事务 A 第一次读取 id=1 当前行数据:name='张三', trx_id=50 可见性判断:trx_id=50 < min_trx_id=100 → 已提交,可见 ✓ 结果:读到 name='张三' T4: 事务 B 修改 id=1,name='张三' → '李四'(trx_id=200) undo log 版本链: 当前版本:name='李四', trx_id=200 ↓ roll_pointer 旧版本:name='张三', trx_id=50 T5: 事务 B 提交 T6: 事务 A 第二次读取 id=1(可重复读) 当前行数据:name='李四', trx_id=200 可见性判断: trx_id=200 >= max_trx_id=101 → 在 Read View 创建后才开始,不可见 ✗ 沿版本链找旧版本: 旧版本:name='张三', trx_id=50 trx_id=50 < min_trx_id=100 → 已提交,可见 ✓ 结果:读到 name='张三'(和第一次一样!实现了可重复读) 总结: 事务 A 两次读取结果相同('张三'),即使事务 B 在中间修改并提交了 这就是可重复读的效果,由 MVCC 的 Read View 机制保证 ```  ### Q:RC 为什么可能出现不可重复读? A:RC 的快照读通常在每次读取时创建新的 Read View,因此后续读取能够看见其他事务已提交的新版本。 ``` 读已提交(RC):每次 SELECT 都重新生成 Read View T3: 事务 A 第一次读取 id=1 此时生成 Read View:m_ids=[100,200], min=100, max=201 当前行:name='张三', trx_id=50 trx_id=50 < min=100 → 可见 结果:读到 name='张三' T4: 事务 B 修改 id=1,name='张三' → '李四'(trx_id=200) T5: 事务 B 提交 T6: 事务 A 第二次读取 id=1 RC 级别:重新生成 Read View! 新 Read View:m_ids=[100](200 已提交,不在活跃列表), min=100, max=201 当前行:name='李四', trx_id=200 可见性判断:trx_id=200 不在 m_ids=[100] 中,且 100 <= 200 < 201 → 已提交,可见 ✓ 结果:读到 name='李四'(和第一次不同!出现了不可重复读) 结论: RC 每次读都生成新 Read View → 能读到其他事务已提交的最新数据 → 不可重复读 RR 整个事务复用同一个 Read View → 只能读到事务开始时的快照 → 可重复读 ``` ## 四、快照读、当前读与幻读 ### Q:幻读为什么不能只用“多读到一行”来理解? A:它涉及范围谓词在并发插入或删除后的结果变化;不同读类型看到的现象与保护手段不同。 ### Q:范围查询中的幻读是怎样发生的? A:当另一事务在查询范围内插入或删除记录后,后续读取可能得到不同的集合。 ``` 幻读:同一事务内,两次相同的范围查询,第二次多出了新行。 场景: 事务 A 查询 status=0 的订单,得到 1 条(id=15) 事务 B 插入一条 status=0 的新订单(id=25)并提交 事务 A 再次查询 status=0 的订单,得到 2 条 → 多出了一条"幻影行",这就是幻读 ``` ### Q:快照读和当前读看到的数据有什么不同? A:普通 SELECT 通常使用快照版本;加锁读和写操作读取当前版本,因此需要额外锁保护范围。 ```sql -- 事务 A(trx_id=100) BEGIN; -- 第一次查询(快照读) SELECT * FROM orders WHERE status = 0; -- 结果:1 行(id=15) -- 此时事务 B 插入新记录并提交: -- INSERT INTO orders VALUES (25, 1004, 0, 199.00, '2024-01-06 15:00:00'); -- 事务 A 第二次查询(快照读) SELECT * FROM orders WHERE status = 0; -- 结果:仍然是 1 行(id=15)← MVCC 快照读,看不到事务 B 插入的数据 -- 快照读不会出现幻读! -- 但如果事务 A 用当前读: SELECT * FROM orders WHERE status = 0 FOR UPDATE; -- 结果:2 行(id=15 和 id=25)← 当前读看到了最新数据,出现幻读! ```  [编辑 Excalidraw 源图](/images/excalidraw/03-transaction-mvcc-phantom-read-protection-diagram.excalidraw) ### Q:当前读如何借助 Next-Key Lock 限制范围插入? A:在满足前提的隔离级别、索引和查询形态下,记录锁与间隙锁组合可阻止其他事务在受保护范围插入。 ```sql -- 事务 A 执行当前读并加锁: SELECT * FROM orders WHERE status = 0 FOR UPDATE; -- InnoDB 会对 status=0 的记录加 Next-Key Lock -- 同时对 status=0 前后的间隙加 Gap Lock -- 这样其他事务就无法在这个范围内插入新的 status=0 的记录 -- 事务 B 尝试插入: INSERT INTO orders VALUES (25, 1004, 0, 199.00, '2024-01-06 15:00:00'); -- 被阻塞!因为 status=0 的间隙被事务 A 的 Gap Lock 锁住了 -- 事务 A 再次查询: SELECT * FROM orders WHERE status = 0 FOR UPDATE; -- 结果:仍然是 1 行(id=15),没有幻读! ```  ### Q:哪些语句属于快照读,哪些属于当前读? A:普通 SELECT 通常是快照读;加锁 SELECT 与 INSERT、UPDATE、DELETE 等会读取当前版本并使用锁。 ``` 快照读(Snapshot Read):读取历史版本,不加锁 普通的 SELECT 语句 当前读(Current Read):读取最新版本,加锁 SELECT ... FOR UPDATE SELECT ... LOCK IN SHARE MODE INSERT / UPDATE / DELETE MVCC 只对快照读有效,当前读需要加锁来保证隔离性 ``` ## 五、把 ACID、MVCC 与日志重新串起来 ### Q:ACID 分别依赖哪些机制? A:undo log 支持回滚,redo log 支持崩溃恢复,MVCC 与锁共同处理隔离;一致性还依赖业务约束和正确使用事务。 ``` 原子性(A): 依赖 undo log 事务执行一半失败时,可以按 undo log 回滚 一致性(C): 本质上是 ACID 其他三个特性 + 业务约束共同保证的结果 隔离性(I): 依赖 MVCC + 锁机制 快照读解决大部分读写并发问题,当前读依赖锁 持久性(D): 依赖 redo log 提交后即使宕机,也能通过 redo log 恢复 ``` ### Q:RC 与 RR 的 Read View 生成时机有什么差别? A:可将 RC 记为“每次快照读更新视图”,RR 记为“事务内复用首个快照读视图”;事务启动与首次读的细节应按实际版本和语句类型确认。 ``` RC(读已提交): 每次快照读都会重新生成一个 Read View 所以更容易读到其他事务最新已提交的数据 RR(可重复读): 事务中的第一次快照读生成一个 Read View 后续快照读都复用这个 Read View 所以同一事务内多次查询结果更稳定 ``` ```text 一句话总结: RC 是“每次读都拍一张新快照”, RR 是“事务里一直看第一次那张快照”。 ```  ### Q:默认 RR 与业务使用 RC 的取舍是什么? A:RR 提供更稳定的事务内快照,RC 往往减少间隙锁相关冲突;应按一致性需求、并发冲突和应用控制策略选择。 ``` MySQL 默认 RR 的原因: 1. 兼顾一致性体验 2. 借助 MVCC 能让普通查询结果更稳定 3. 配合 Next-Key Lock 能更好处理幻读问题 很多大厂改 RC 的原因: 1. RC 锁冲突更少,并发更高 2. 更容易减少间隙锁带来的阻塞 3. 在大量互联网业务里,“高并发 + 明确当前读控制”往往更重要 ``` ``` 所以不是谁绝对更好, 而是不同业务在“一致性体验”和“并发吞吐”之间做取舍。 ``` ### Q:RR 是否完全解决了幻读? A:不能脱离读类型回答。快照读依赖 MVCC 稳定视图;当前读依赖锁范围,特定时序仍应结合语义和版本验证。 ``` 没有一句话能简单回答“完全解决”或“完全没解决”, 要分场景: 1. 快照读 普通 SELECT 在 RR 下通过 MVCC 读的是事务快照 所以通常不会看到别人后来插入的新记录 2. 当前读 SELECT ... FOR UPDATE / UPDATE / DELETE 这类当前读 需要依赖 Next-Key Lock / Gap Lock 来防止别人插入 ``` ``` 所以更准确的说法是: RR 通过“MVCC + 间隙锁”解决了大多数幻读问题, 但在特定时序和特定读法下,仍然需要结合当前读语义去理解。 ``` ### Q:哪些边界场景需要谨慎讨论 RR 与幻读? A:快照读与当前读交替、事务中修改此前不可见的新记录等场景,不能只用“完全解决”或“完全没解决”概括。 > 也就是说在快照读和当前读的间隙 ### Q:面试中如何准确概括 InnoDB RR 的幻读处理? A:可说 RR 通过 MVCC 稳定快照读,并在当前读场景借助 Next-Key/Gap Lock 处理大多数范围插入问题;边界行为需结合具体语句、索引和时序。 InnoDB的RR隔离级别只解决了大多数的幻读问题,并没有解决所有的幻读问题。要想全部解决,还是要使用Serializable的隔离级别。 具体来说,就是在RR中解决了所有快照都的幻读问题,因为快照只会生成一次,后续都根据这个快照读,所以不会发生幻读。但是针对当前读,只能解决部分幻读问题。 **但是,如果两个事务,事务1先进行快照读,然后事务2插入了一条记录并提交,再在事务1中进行update新插入的这条记录是可以更新成功的,这就是发生了幻读。** **还有一种场景,如果两个事务,事务1先进行快照读,然后事务2插入了一条记录并提交,在事务1中进行了当前读之后,再进行快照读也会发生幻读。** ## 六、快速复盘:高频追问 ### Q:MVCC 是什么?解决了什么问题? A:MVCC(多版本并发控制)通过保存数据的多个历史版本,让读操作不需要加锁,写操作不阻塞读操作,提高并发性能。实现依赖三个组件:隐藏字段(trx_id、roll_pointer)、undo log(版本链)、Read View(可见性判断)。 ### Q:可重复读和读已提交在 MVCC 实现上有什么区别? A:区别在于 Read View 的生成时机。可重复读在事务开始时生成一次 Read View,整个事务复用;读已提交每次 SELECT 都重新生成 Read View。所以读已提交能读到其他事务已提交的最新数据,而可重复读只能读到事务开始时的快照。 ### Q:Read View 中的 m_ids、min_trx_id、max_trx_id 分别是什么? A:m_ids 是生成 Read View 时所有活跃(未提交)事务的 ID 列表;min_trx_id 是 m_ids 中最小的事务 ID;max_trx_id 是下一个将要分配的事务 ID(当前最大 ID + 1)。可见性判断:trx_id < min_trx_id 表示已提交可见;trx_id >= max_trx_id 表示还未开始不可见;在两者之间则看是否在 m_ids 中。 ### Q:InnoDB 的可重复读能解决幻读吗? A:能解决大部分幻读,但不是完全解决。对于快照读(普通 SELECT),MVCC 可以避免幻读;对于当前读(SELECT FOR UPDATE),需要配合间隙锁(Gap Lock)来防止其他事务插入数据,从而避免幻读。 ### Q:为什么转账操作必须放在事务中? A:转账涉及两步操作(扣减 A 的余额、增加 B 的余额),必须保证原子性——要么都成功,要么都失败。如果没有事务,第一步成功后服务器宕机,会导致 A 的钱扣了但 B 没收到,数据不一致。事务通过 undo log 保证原子性,任何一步失败都能回滚到初始状态。 ## 总结:用一句话记住 事务提供业务原子边界;MVCC 用版本链和 Read View 支持非阻塞快照读;当前读仍要依赖锁。理解“读的类型”和“版本是否可见”,比孤立背诵隔离级别更可靠。 --- 上一篇:[02 - 索引原理与优化](./02-index.md) | 下一篇:[04 - MySQL 日志体系](./04-logs.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入