MySQL崩溃恢复机制_Redo与Undo日志_CSDN博客

Source

彻底搞懂 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 变化。

目录

  1. 从一条 UPDATE 说起:为什么需要日志
  2. Undo Log:事务的原子性
  3. MVCC:多版本并发控制详解
  4. Redo Log:事务的持久性与 WAL
  5. 崩溃恢复的全过程:重做 + 回滚
  6. 两阶段提交:Redo Log 与 Binlog 的一致性
  7. 三大日志对比总览
  8. 生产配置建议
  9. 总结

一、从一条 UPDATE 说起:为什么需要日志

思考三个问题:

  1. 一条 UPDATE 操作的数据可能分布在多个数据页(默认 16KB),直接刷盘是随机 IO,又慢又贵。MySQL 凭什么还那么快?
  2. 执行过程中 MySQL 突然宕机,怎么保证这条记录要么完整生效、要么完全不生效?
  3. 主从架构下,主库的变更怎么同步到从库?

这三个问题,分别对应 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 有严格的先后顺序:

  1. 更新数据前,先记录 Undo Log;
  2. 出错或执行 ROLLBACK 时,沿 Undo Log 的逆操作恢复数据;
  3. 磁盘上尚未被事务修改的数据,仍保持事务开始前的状态。

一个容易被忽略的点: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 条规则:

  1. trx_id == creator_trx_id → 自己改的,可见;
  2. trx_id < min_trx_id → 该版本在 ReadView 创建前已提交,可见;
  3. trx_id >= max_trx_id → 该版本在 ReadView 创建后才开始,不可见(沿链向上找上一版本);
  4. 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 回滚)。

恢复流程(重启时):

  1. Redo 重做:从 checkpoint 开始,按 LSN 顺序重放 Redo Log,把已提交但未刷盘的数据页重做到内存;
  2. 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,让读写并发不再互相阻塞。

👍 一键三连
如果这篇笔记帮你理清了三范式、顺手拿下了面试题,麻烦来个三连支持一下~
💛 点赞 = 我学会了
⭐ 收藏 = 下次建表照着抄,面试前翻出来复习
💬 评论 = 留下你的疑问或想看的主题

参考链接