彻底搞懂 MySQL 崩溃恢复:Redo Log、Undo Log、MVCC 与两阶段提交
数据库崩溃(断电、宕机)时,MySQL 凭什么保证「已提交的事务不丢、未提交的事务不留」?答案就是 Undo Log(回滚日志) 和 Redo Log(重做日志) 两大日志的协同工作。
本文从「为什么要日志」讲起,系统拆解 Undo Log 的原子性原理、Redo Log 的 WAL 机制与刷盘策略、崩溃恢复全过程、MVCC 多版本并发控制,以及 Redo Log 与 Binlog 的两阶段提交,并覆盖 MySQL 8.0.30 的 redo log 变化。
目录
- 从一条 UPDATE 说起:为什么需要日志
- Undo Log:事务的原子性
- MVCC:多版本并发控制详解
- Redo Log:事务的持久性与 WAL
- 崩溃恢复的全过程:重做 + 回滚
- 两阶段提交:Redo Log 与 Binlog 的一致性
- 三大日志对比总览
- 生产配置建议
- 总结
一、从一条 UPDATE 说起:为什么需要日志
思考三个问题:
- 一条
UPDATE操作的数据可能分布在多个数据页(默认 16KB),直接刷盘是随机 IO,又慢又贵。MySQL 凭什么还那么快? - 执行过程中 MySQL 突然宕机,怎么保证这条记录要么完整生效、要么完全不生效?
- 主从架构下,主库的变更怎么同步到从库?
这三个问题,分别对应 InnoDB 的三大日志:
| 日志 | 所属层 | 作用 | 核心目标 |
|---|---|---|---|
| Undo Log(回滚日志) | InnoDB 引擎层 | 事务回滚、MVCC | 原子性 |
| Redo Log(重做日志) | InnoDB 引擎层 | 崩溃恢复(crash-safe) | 持久性 |
| Binlog(归档日志) | Server 层 | 主从复制、增量恢复 | 可追溯 |
一句话:Undo Log 保证原子性(能回滚),Redo Log 保证持久性(能重做),Binlog 保证可追溯与主从同步。
二、Undo Log:事务的原子性
1. 为什么需要 Undo Log
事务的原子性(Atomicity):事务中的所有操作,要么全部完成,要么不做任何操作。执行过程中出错,要**回滚(Rollback)**到事务开始前的状态,就像从未执行过。
原理:在修改任何数据之前,先把数据备份到一个地方(Undo Log),再进行修改。如果出错或用户执行 ROLLBACK,就利用备份把数据恢复到事务开始前的状态。
Undo Log 记录的是「修改前的旧数据」—— 一条与当前操作相反的逻辑日志:
DELETE记录一条INSERT,UPDATE记录一条相反的UPDATE。
2. Undo Log 的另一个作用:MVCC
除了回滚,Undo Log 还支撑多版本并发控制(MVCC)——这是本篇文章接下来要重点展开的内容(见第三节)。
3. Undo Log 的持久化:也受 Redo Log 保护(关键)
为了保证原子性,Undo Log 有严格的先后顺序:
- 更新数据前,先记录 Undo Log;
- 出错或执行
ROLLBACK时,沿 Undo Log 的逆操作恢复数据; - 磁盘上尚未被事务修改的数据,仍保持事务开始前的状态。
一个容易被忽略的点:Undo Log 本身也存放在数据页(undo 页)里,同样跟随 Buffer Pool 的刷盘机制,存在「内存里有、磁盘上还没写」的丢失风险。所以 Undo Log 的修改也会记录到 Redo Log——由 Redo Log 保证 Undo Log 不丢。这也解释了为什么「回滚」能力最终也依赖 Redo Log 的持久化。
一句话:数据靠 Redo 重做、靠 Undo 回滚;而 Undo 自己,也靠 Redo 保护。
4. Undo Log 的缺陷
每个事务提交前都要把「数据 + Undo Log」都写磁盘,导致大量磁盘 IO,性能很低。如果能把数据在内存里缓存一段时间,就能减少 IO、提升性能,但会丧失持久性。
于是引入了 Redo Log 来解决持久性问题。
三、MVCC:多版本并发控制详解
1. MVCC 是什么、解决什么问题
MVCC(Multi-Version Concurrency Control,多版本并发控制):通过保留数据的历史版本,让读操作不加锁也能读到一致性快照,从而实现「读不阻塞写、写不阻塞读」,大幅提升并发读写性能。
- 只在 InnoDB 引擎下存在(MyISAM 不支持);
- 只在 RC(读已提交) 和 RR(可重复读) 两个隔离级别下生效;
- RU(读未提交)总是读最新行、Serializable 对所有读加锁,都不用 MVCC。
2. 三个核心组件
MVCC 由三部分组成:隐藏字段 + Undo Log 版本链 + ReadView。
组件一:隐藏字段
InnoDB 聚簇索引的每条记录都包含隐藏列:
| 隐藏列 | 含义 |
|---|---|
DB_TRX_ID |
最近一次创建/修改该记录的事务 ID |
DB_ROLL_PTR |
回滚指针,指向 Undo Log 中该记录的上一个版本 |
DB_ROW_ID |
隐藏主键(rowid),仅当表没有定义主键/唯一索引时才存在,单调递增 |
其中
DB_TRX_ID和DB_ROLL_PTR是聚簇索引记录必要的两个隐藏列;DB_ROW_ID只在无主键时作为兜底主键存在。
组件二:Undo Log 版本链
每次对记录修改,都会写一条 Undo Log(保存旧值),每条 Undo Log 也有 DB_ROLL_PTR,指向更早的版本,串成一个版本链:
最新记录(链头) → 上一版本 → 更早版本 → ... → 最早版本(链尾)
- 链头是记录当前最新值,链尾是最早版本;
INSERT对应的 Undo Log 没有DB_ROLL_PTR(因为该记录没有更早版本);- 每个版本都包含生成该版本时的事务 ID(trx_id)。
注意:一条记录被多个事务修改时,是串行的——InnoDB 用锁防止「脏写」(一个事务改到另一个未提交事务已改的数据),所以版本链是顺序追加的。
组件三:ReadView(读视图)
ReadView 是事务进行快照读时生成的一致性读视图,记录生成瞬间的系统状态,用于判断版本链中哪个版本对当前事务可见。四个字段:
| 字段 | 含义 |
|---|---|
m_ids / trx_ids |
生成 ReadView 时,活跃(未提交)事务的 ID 列表 |
min_trx_id / up_limit_id |
活跃事务中最小的事务 ID |
max_trx_id / low_limit_id |
生成 ReadView 时系统应分配给下一个事务的 ID(= 全局最大事务 ID + 1,不是活跃事务最大 ID) |
creator_trx_id |
创建该 ReadView 的事务自己的 ID |
3. 可见性判断算法(核心)
从版本链最新版本开始,拿版本的 trx_id 与 ReadView 比较,4 条规则:
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→ 若trx_id在m_ids中(未提交),不可见;否则(已提交)可见。
用伪代码表示:
function isVisible(trx_id, view) {
if (trx_id == view.creator_trx_id) return true; // 自己改的
if (trx_id < view.min_trx_id) return true; // 已提交
if (trx_id >= view.max_trx_id) return false; // 未开始
return !view.m_ids.includes(trx_id); // 活跃→不可见,否则已提交→可见
}
一个完整的 SELECT 判定流程:
1. InnoDB 收到 SELECT id=1 的请求
2. 从聚簇索引找到 id=1 的记录行,拿到 DB_TRX_ID
3. 拿 DB_TRX_ID 与当前事务的 ReadView 比较(上面 4 条规则)
4. 若当前版本不可见,沿 DB_ROLL_PTR 找上一个版本,重复第 3 步
5. 直到找到可见版本,或遍历到链尾返回 NULL
4. RC 与 RR 的核心区别:ReadView 生成时机
MVCC 让 RC、RR 产生差异的关键,就在于 ReadView 什么时候生成:
| 隔离级别 | ReadView 生成时机 |
|---|---|
| 读已提交(RC) | 每次 SELECT 都重新生成新的 ReadView |
| 可重复读(RR) | 第一次 SELECT 生成后,事务期间一直复用 |
- RC:因为每次 SELECT 都用新 ReadView,所以能读到别的事务已提交的最新数据;
- RR:因为复用同一个 ReadView,所以同一事务内每次读到的一致,实现可重复读。
补充:RR 下用
START TRANSACTION WITH CONSISTENT SNAPSHOT会在事务开始时立即创建快照,而不是等到第一次 SELECT。
5. 快照读 vs 当前读
| 类型 | 是什么 | 是否加锁 | 读到什么 |
|---|---|---|---|
| 快照读(一致性非锁定读) | 普通 SELECT |
不加锁 | 历史版本快照(走 MVCC) |
| 当前读(锁定读) | SELECT ... FOR UPDATE、SELECT ... LOCK IN SHARE MODE、INSERT/UPDATE/DELETE |
加锁 | 最新已提交版本 |
关键理解:
UPDATE/DELETE本质是「当前读」,总是读取最新版本并加锁。所以先快照读看到旧值、再UPDATE时,会用当前读拿到别人已提交的最新值再改,避免丢失更新。
6. MVCC 如何解决幻读
InnoDB 默认隔离级别是 RR(可重复读),它用两套机制分别解决两类读的幻读:
| 读类型 | 解决幻读的手段 |
|---|---|
| 快照读 | MVCC(复用 ReadView,快照始终一致) |
| 当前读 | LBCC 锁(临键锁 Next-Key Lock = 记录锁 + 间隙锁) |
一句话:MVCC 解决快照读的幻读,间隙锁/临键锁解决当前读的幻读。
7. Undo Log 的清理:purge 线程
Undo Log 不能无限增长,由后台 purge 线程异步清理:
- insert undo:只在回滚时需要,事务提交后即可立即删除;
- update/delete undo:回滚需要、MVCC 快照读也需要,必须等没有任何活跃事务(一致读或回滚)还依赖它时才能清除。
所以长事务、大事务会让版本链变长、undo 膨胀,是线上需要重点盯的问题。
四、Redo Log:事务的持久性与 WAL
1. 原理:和 Undo Log 相反
Redo Log 记录的是新数据的备份(修改动作),而不是旧数据:
- 事务提交前,只要把 Redo Log 持久化即可,不需要把数据页持久化;
- 系统崩溃时,虽然数据页没刷盘,但 Redo Log 已持久化,重启后按 Redo Log 重做(Redo),把所有数据恢复到最新状态。
这就是 WAL(Write-Ahead Logging,预写式日志):先写日志,再写磁盘。
2. 为什么需要 Redo Log:Buffer Pool 带来的持久性风险
InnoDB 的数据在磁盘,但每次读写都走磁盘 IO 效率太低,所以引入了 Buffer Pool(缓冲池):
- 读:先读 Buffer Pool,没有才从磁盘加载;
- 写:先写 Buffer Pool(修改后的页叫脏页),再定期刷到磁盘(刷脏)。
问题来了:如果 Buffer Pool 中的脏页还没刷盘,MySQL 就宕机了,修改就丢了。Redo Log 就是来兜底的—— 修改数据时,除了改 Buffer Pool,还记 Redo Log;事务提交时对 Redo Log 刷盘。宕机后重放 Redo Log 即可恢复。
3. 为什么写 Redo Log 比直接刷脏快
| 维度 | 刷脏(写数据页) | 写 Redo Log |
|---|---|---|
| IO 类型 | 随机 IO | 顺序 IO(追加写) |
| 写入单位 | 整页(默认 16KB),改一点点也要整页写 | 只写真正变更的部分 |
顺序写 + 记录级粒度,让 Redo Log 的写入开销远小于直接刷脏,这就是 WAL 能「既保持久性、又提性能」的根因。
4. Redo Log 的结构:环形 + 双指针
Redo Log 是固定大小、循环写的(类似环形缓冲区):
ib_logfile0 → ib_logfile1 → (写满后回到) ib_logfile0
MySQL 8.0.30+ 的变化:不再用两个
ib_logfile文件,而是用innodb_redo_log_capacity控制 redo 总容量(默认 100MB),InnoDB 在数据目录的#innodb_redo目录维护约 32 个 redo 文件,并支持运行时动态调整容量;innodb_log_file_size、innodb_log_files_in_group已废弃。核心的「环形 + 双指针 + 写满暂停」思想不变。
有两个指针:
- write pos:当前写入位置,随着写入往后推进;
- checkpoint:当前已刷盘的位置,脏页刷盘后 checkpoint 往前推进。
write pos 与 checkpoint 之间的空间,是还可以写入的部分。当 write pos 追上 checkpoint(写满),必须停下来,先把旧记录对应的脏页刷盘、擦除旧记录腾出空间,才能继续写入 ——这期间不能接收新的更新请求,可能导致 MySQL 卡顿。
所以:并发量大的系统,适当调大 Redo Log 文件大小非常重要!(参数
innodb_log_file_size)
5. LSN:日志序列号
每条 Redo Log 记录都有一个全局唯一、递增的 LSN(Log Sequence Number)。崩溃恢复时按 LSN 顺序重放,判断哪些已提交、哪些未提交。
Redo Log 记录的是物理修改,类似「在 X 表空间的 N 数据页 ZZ 偏移量处做了 AAAA 更新」,是数据页的「修改痕迹」,二进制不可读。
6. 刷盘策略:innodb_flush_log_at_trx_commit
| 值 | 行为 | 性能 | 安全性 | 说明 |
|---|---|---|---|---|
| 0 | 每秒刷一次(不依赖事务提交) | 高 | 低 | 可能丢 1 秒数据 |
| 1 | 每次事务提交都 fsync 刷盘 |
低 | 高 | 默认,推荐,crash-safe |
| 2 | 每次提交写 OS Buffer,每秒刷盘 | 中 | 中 | 只丢 OS 缓存,不丢事务 |
生产环境强烈建议设为 1,牺牲一点性能换取「已提交数据绝不丢失」。
五、崩溃恢复的全过程:重做 + 回滚
crash-safe 能力:有了 Redo Log 和 Undo Log,InnoDB 能保证 —— 即使事务提交的任何阶段宕机,重启后:
- 已提交的事务不丢(Redo Log 重做);
- 未提交的事务不留(Undo Log 回滚)。
恢复流程(重启时):
- Redo 重做:从 checkpoint 开始,按 LSN 顺序重放 Redo Log,把已提交但未刷盘的数据页重做到内存;
- Undo 回滚:扫描未完成事务,用 Undo Log 回滚到事务开始前状态。
华为云对崩溃恢复的概括:扫描 last checkpoint 之后的日志,重放「已提交但尚未落盘」的操作以恢复丢失的内存修改;同时用 Undo 回滚未提交事务的部分修改,保证「已提交的持久性 + 未提交的原子性」。
判断依据:重启时比较数据页的 LSN 与 checkpoint 的 LSN,从 checkpoint 开始恢复。
六、两阶段提交:Redo Log 与 Binlog 的一致性
1. 为什么需要两阶段提交
事务提交时,既写 Redo Log,又写 Binlog。如果顺序不对,会出问题:
场景假设:写完 Redo Log 就提交,然后宕机 → Redo Log 有记录、Binlog 没有 → 主库恢复了,从库没这条变更 → 主从数据不一致。
2. 两阶段提交流程
1. 写 Redo Log,标记为 prepare 状态(含 XID),持久化到磁盘
2. 写 Binlog 并刷盘(含 XID)
3. 将 Redo Log 的 prepare 状态改为 commit(此状态本身无需再刷盘)
分两个阶段,故称「两阶段提交」:prepare(准备)→ commit(提交)。本质是内部 XA 事务,通过 XID 把 Redo Log 与 Binlog 两份日志关联起来。
补充:只要 Binlog 已持久化,无论 Redo Log 处于 prepare 还是 commit 状态,都认为该事务已完成持久化——所以第 3 步的 commit 标记不必强制刷盘。
3. 中途宕机如何恢复
重启后扫描 Redo Log,对处于 prepare 状态的记录,拿着其中的 XID 去 Binlog 查:
- Binlog 里没有该 XID → 说明 Redo Log 刷盘了、Binlog 没刷盘 → 回滚事务(对应「写完 Redo Log 后宕机」);
- Binlog 里有该 XID → 说明两者都已刷盘 → 提交事务(对应「写完 Binlog 后、写 commit 标记前宕机」)。
本质:以 Binlog 写成功作为事务提交成功的标识,从而保证 Redo Log 与 Binlog 两份日志的一致性。这套机制让 InnoDB 拥有崩溃恢复能力,Binlog 则保证主从/集群的数据一致。
七、三大日志对比总览
| 特性 | Redo Log | Binlog | Undo Log |
|---|---|---|---|
| 所属层 | InnoDB 引擎层 | Server 层 | InnoDB 引擎层 |
| 记录内容 | 物理变更(页级修改) | SQL 逻辑变更 | 事务历史版本(逆操作) |
| 作用 | 持久性、崩溃恢复 | 主从同步、增量恢复 | 事务回滚、MVCC |
| 写入方式 | 循环写 | 追加写 | 回滚段管理 |
| 大小 | 固定大小 | 持续增长 | 可增长 |
| 清理方式 | checkpoint 覆盖 | 手动/按保留天数清理 | 事务完成 + purge 清理 |
八、生产配置建议
[mysqld]
# 关键:每次事务提交刷盘,保证 crash-safe
innodb_flush_log_at_trx_commit = 1
# binlog 每次事务提交刷盘(配合两阶段提交保证一致性)
sync_binlog = 1
# 内存日志缓冲
innodb_log_buffer_size = 16M
# ===== MySQL 5.7 / 8.0.30 之前 =====
# Redo Log 大小(并发大的系统建议调大,避免写满卡顿)
innodb_log_file_size = 512M
innodb_log_files_in_group = 2
# ===== MySQL 8.0.30 及以后 =====
# 用容量参数替代上面两个旧参数(默认 100MB,可运行时动态调整)
innodb_redo_log_capacity = 536870912 # 512MB
九、总结
| 问题 | 答案 |
|---|---|
| 原子性靠谁? | Undo Log(记录修改前旧数据,支持回滚) |
| 持久性靠谁? | Redo Log(记录修改动作,WAL 先写日志后写磁盘) |
| 隔离性靠谁? | 锁 + MVCC(隐藏字段 + Undo 版本链 + ReadView) |
| MVCC 的 RC/RR 差异? | ReadView 生成时机:RC 每次生成、RR 首次生成后复用 |
| 为什么快? | Redo Log 顺序写、只写变更部分,远快于随机刷脏 |
| 崩溃怎么恢复? | Redo 重做已提交事务 + Undo 回滚未提交事务 |
| Redo 与 Binlog 怎么一致? | 两阶段提交(prepare → 写 binlog → commit) |
一句话记忆:Undo Log 管「回滚」,Redo Log 管「重做」,Binlog 管「同步与追溯」,三者协同,撑起 MySQL 事务的 ACID 与崩溃安全;而 Undo Log + ReadView + 隐藏字段 三者又构成了 MVCC,让读写并发不再互相阻塞。
👍 一键三连
如果这篇笔记帮你理清了三范式、顺手拿下了面试题,麻烦来个三连支持一下~
💛 点赞 = 我学会了
⭐ 收藏 = 下次建表照着抄,面试前翻出来复习
💬 评论 = 留下你的疑问或想看的主题
参考链接
- MySQL 的日志:undo log、redo log、binlog 有什么作用
- MySQL 的 crash-safe 原理详解
- 深入解析 MySQL 日志系统:undo log、redo log、bin log
- MySQL 日志:Redo、Bin 与 Undo Log
- MySQL 的事务隔离是如何实现的:ReadView 与版本链
- 一篇文章彻底搞懂 MySQL 之 MVCC 机制
- MVCC 是如何解决幻读的
- 数据库三大日志深度解析:Redo Log、Binlog、Undo Log
- 详解 MySQL 三大核心日志 binlog/redolog/undolog 原理及协作
- MySQL 两阶段提交与组提交保证 RedoLog 和 Binlog 一致性
- MySQL 崩溃保险箱:探秘 Redo/Undo 日志
- MySQL 中的 Redo Log、Undo Log 和 Binlog 深入解析
- 第16章 多版本并发控制
- 深入理解 MySQL 的 MVCC 原理
- 深入探究 InnoDB 的 MVCC 快照机制
- InnoDB MVCC 机制详解:快照读、当前读、Undo 链
- MySQL 三大日志底层原理全拆解
- 硬核干货!一文掌握 binlog、redo log、undo log
- InnoDB 崩溃恢复实战:WAL、checkpoint 与恢复过程拆解
- 深入理解 MySQL 事务:ACID 特性及其实现原理
- 深度好文:MySQL InnoDB 事务隔离与 MVCC、版本链与 ReadView
- 深入讲解 InnoDB 解决幻读:LBCC + MVCC
- MVCC 原理分析 + 源码解读
- InnoDB Redo Log Persistence Analysis
- MySQL 8.0 Redo Log 官方文档(Oracle/MySQL)
- Changes in MySQL 8.0.30:Dynamic Redo Log(Oracle)