MySQL 三大日志:undo log、redo log 与 binlog
面试频率:★★★★★
工作频率:★★★★☆
学习重点:三种日志各自解决什么问题、WAL 思想,以及两阶段提交
⚡ 30 秒速记
三大日志一句话:
undo log(回滚日志)
↓
记录"怎么改回去"
↓
事务回滚 + MVCC 历史版本
redo log(重做日志)
↓
记录"数据页改了什么"
↓
崩溃恢复,保证持久性
binlog(归档日志)
↓
记录"执行了哪些操作"
↓
主从复制 + 数据恢复
一张表记住区别:
| 日志 | 所在层 | 内容 | 主要作用 | 写入方式 |
|---|---|---|---|---|
| undo log | InnoDB 引擎层 | 逻辑反操作 | 回滚、MVCC 版本链 | 随事务产生 |
| redo log | InnoDB 引擎层 | 物理修改 | 崩溃恢复 | 循环写 |
| binlog | Server 层 | 逻辑操作 | 主从复制、数据恢复 | 追加写 |
最重要的思想:
WAL(Write-Ahead Logging):先写日志,再慢慢刷数据页。
以及一个高频考点:
redo log 和 binlog 的一致性
↓
两阶段提交
↓
prepare → 写binlog → commit
🎤 面试回答
面试官:
MySQL 有哪些日志?分别有什么用?
可以回答:
MySQL 最核心的是三大日志:undo log、redo log 和 binlog。
undo log 是回滚日志,记录修改的反操作,主要用于事务回滚,同时也是 MVCC 版本链的来源。
redo log 是 InnoDB 的重做日志,记录数据页级别的物理修改,核心作用是崩溃恢复:MySQL 重启后通过重放 redo log,把已提交但还没刷盘的修改恢复回来,保证持久性。它基于 WAL 思想,先顺序写日志,再异步刷数据页。
binlog 是 Server 层的归档日志,记录逻辑层面的操作,主要用于主从复制和数据恢复。
因为 redo log 和 binlog 是两套独立的日志,MySQL 通过两阶段提交保证它们一致:redo log 先进入 prepare 状态,binlog 写盘成功后再置为 commit。崩溃恢复时,处于 prepare 的 redo log 如果在 binlog 中有完整记录就提交,否则回滚。
一、为什么改数据不直接写磁盘?
假设执行:
UPDATE account
SET balance = 500
WHERE id = 1;
MySQL 的数据存在磁盘上。
如果每次修改都直接写磁盘:
UPDATE
↓
找到张三所在的数据页(16KB)
↓
把页读入内存
↓
只改其中几十个字节
↓
整页写回磁盘
↓
随机IO
↓
很慢
问题核心:
一次修改
↓
只动几十个字节
↓
却要为它做一次磁盘随机IO
数据库的解决思路:
把随机写
↓
变成
↓
顺序写
也就是:
先把修改顺序写到日志文件里,数据页之后慢慢刷。
这就是:
WAL
=
Write-Ahead Logging
=
先写日志
二、Buffer Pool:修改其实发生在内存
InnoDB 不会每次修改都碰磁盘。
它维护了一块内存区域:
Buffer Pool(缓冲池)
UPDATE 的真实流程:
UPDATE 张三余额 1000 → 500
↓
张三的数据页在Buffer Pool里吗?
↙ ↘
在 不在
↓ ↓
直接修改 先从磁盘把这一页读进来
↓ ↓
修改内存中的数据页
修改完成后:
磁盘上的页:张三 = 1000
内存中的页:张三 = 500
这时候这个页叫做:
脏页(Dirty Page)
脏页 = 内存里改过、但还没刷回磁盘的页。
后台线程会在合适的时机刷脏页:
后台线程
↓
挑选一些脏页
↓
刷回磁盘
↓
内存和磁盘重新一致
三、内存里的修改丢了怎么办?
现在有一个严重问题:
UPDATE已经执行
↓
只改了内存(脏页)
↓
还没刷回磁盘
↓
此时MySQL崩溃了
重启之后:
内存数据全部丢失
↓
磁盘上还是旧值
↓
张三 = 1000
↓
但事务明明已经COMMIT了
这就违反了事务四大特性中的:
持久性(Durability)
已提交的事务,崩溃之后不能丢。
靠什么保证?
redo log
四、redo log 是什么?
redo log
=
重做日志
属于:
InnoDB 引擎层
它记录的是:
某个数据页做了什么物理修改。
例如可以粗略理解成:
第 X 号数据页
偏移量 Y 处
改成了:500
工作方式:
UPDATE
↓
修改Buffer Pool中的页(产生脏页)
↓
同时顺序写redo log
↓
COMMIT时保证redo log落盘
↓
崩溃后重启
↓
重放redo log
↓
已提交的修改恢复回来
这个能力叫:
crash-safe
=
崩溃恢复
先记住一个对比,后文展开:
binlog 没有 crash-safe 能力
能做崩溃恢复的
↓
只有 InnoDB 的 redo log
五、redo log 是"物理日志"
redo log 记录的是物理层面的修改:
哪个数据页
哪个位置
改成了什么
可以粗略理解:
redo log 不关心你的 SQL 长什么样,只关心"哪个页的哪个地方被改了"。
而后面要讲的 binlog 记录的是逻辑操作(语句或行的变更)。
这是两者最核心的区别之一:
redo log:物理日志(页级别的修改)
binlog :逻辑日志(语句 / 行级别的变更)
六、redo log 为什么快?
磁盘写有两种:
随机写
↓
这次写这个位置
下次写那个位置
↓
磁头来回寻道
↓
慢
顺序写
↓
一直往后追加
↓
像记流水账
↓
快
redo log 是顺序写:
redo log文件
↓
一直往后追加
↓
顺序IO
↓
快
而脏页刷盘是随机写:
张三的页在磁盘这一头
李四的页在磁盘那一头
↓
随机IO
↓
慢
所以 WAL 的本质:
用顺序写的日志
↓
代替(推迟)
↓
随机写的数据页
七、redo log 是循环写的
redo log 是固定大小的,通常是一组文件:
ib_logfile0
ib_logfile1
...
写法是循环写:
write pos
↓
当前写入位置,一直往后写
check point
↓
这个位置之前的修改
都已经刷到数据文件了
对应的redo log可以被覆盖
图:
check point write pos
↓ ↓
┌───────────┬──────────────────┬───────────┐
│ 可覆盖重用 │ 修改还没刷盘的redo │ 可覆盖重用 │
└───────────┴──────────────────┴───────────┘
(write pos 继续往后写,
写到文件末尾就绕回头部)
两个位置一直往前推进:
后台刷脏页
↓
check point 往前推
↓
腾出可写的空间
write pos 一直往后写
如果 write pos 追上了 check point:
redo log 写满了
↓
必须停下来推进check point(强制刷脏页)
↓
UPDATE 被阻塞
↓
写入卡顿
所以:
redo log 空间不是无限的。写满时会阻塞更新,这是线上写入抖动的经典原因之一。
redo log 设置得太小
↓
频繁写满
↓
周期性卡顿
对比记忆:
redo log:循环写,会覆盖旧内容
binlog :追加写,写满一个文件换下一个,不覆盖
八、redo log 什么时候真正落盘?
redo log 的写入有三层:
redo log buffer(InnoDB内存中的日志缓冲)
↓
OS cache(操作系统页缓存)
↓
磁盘
什么时候真正 fsync 到磁盘,由参数控制:
innodb_flush_log_at_trx_commit
三个取值:
= 1(默认)
↓
每次事务提交都fsync到磁盘
↓
最安全
↓
崩溃不丢任何已提交事务
= 0
↓
提交时只写redo log buffer
↓
后台每秒刷一次
↓
崩溃可能丢1秒的事务
= 2
↓
提交时写到OS cache
↓
每秒fsync
↓
MySQL进程崩了不丢
操作系统/机器崩了才丢
对数据安全性要求最高的场景:
= 1
九、undo log 是什么?
undo log
=
回滚日志
属于:
InnoDB 引擎层
两大作用:
1. 事务回滚
2. MVCC 历史版本
十、undo log 记录的是"反操作"
undo log 是逻辑日志,记录的是怎么把修改改回去:
INSERT 一条记录
↓
undo log 记录:删除这条记录
DELETE 一条记录
↓
undo log 记录:把这条记录原样插回去
UPDATE 1000 → 500
↓
undo log 记录:500 → 1000
回滚时:
ROLLBACK
↓
执行undo log中的反操作
↓
数据恢复原样
注意方向:
redo log:正向操作(改了什么,重做用)
undo log:反向操作(怎么改回去,回滚用)
十一、undo log 和 MVCC:你早就用过它了
这是和之前 MVCC 那篇的连接点。
学 MVCC 时讲过版本链:
当前版本:张三 = 500
↓ roll_pointer
历史版本:张三 = 1000
↓ roll_pointer
更老版本:张三 = 800
当时说过历史版本来自 undo log。
现在可以把话说全了:
undo log
↓
既服务于回滚
↓
也服务于MVCC
图:
undo log
│
┌───────┴───────┐
↓ ↓
rollback MVCC
↓ ↓
反向恢复 版本链的历史版本
所以 MVCC 那篇里"数据库最新是 500、事务还能读到 1000",本质就是:
旧版本信息还留在undo log里
↓
沿着roll_pointer一路找
↓
用Read View判断可见性
↓
返回1000
十二、undo log 是提交后就删吗?
不是。
原因:
事务A修改了数据并提交
↓
但事务B可能还开着
↓
B的Read View可能还需要A修改前的旧版本
↓
undo log 不能删
清理工作由:
purge 线程
负责:
purge线程
↓
确认没有任何活跃事务还需要某个旧版本了
↓
才清理对应的undo log
这就引出一个和上一篇呼应的问题。
上一篇(锁机制)说过:
长事务
↓
长时间持有锁
↓
其他事务锁等待
这一篇又看到:
长事务
↓
很早的Read View一直存在
↓
大量undo log无法清理
↓
undo表空间膨胀
两篇从不同角度得到同一个结论:
工作中避免长事务。
十三、binlog 是什么?
binlog
=
归档日志 / 二进制日志
属于:
Server 层
注意这个层级区别:
binlog 是 MySQL Server 层的日志,所有存储引擎共用;redo log 和 undo log 是 InnoDB 引擎层的,别的引擎没有。
binlog 记录的是逻辑操作:
插入了什么数据
更新了哪些行
删除了哪些行
两大用途:
1. 主从复制
↓
从库拉取主库的binlog
↓
重放执行
↓
主从数据一致
2. 数据恢复
↓
全量备份 + 重放binlog
↓
恢复到备份之后的任意时间点
十四、binlog 的三种格式
STATEMENT
↓
记录SQL语句本身
↓
日志量小
↓
但now()、uuid()、limit顺序
可能导致主从执行结果不一致
ROW(MySQL 5.7之后的默认)
↓
记录每一行数据的实际变更
↓
准确,主从一致
↓
但日志量大
MIXED
↓
默认用STATEMENT
↓
检测到可能不一致的语句时
自动改用ROW
面试能说出 STATEMENT 的坑、以及 ROW 为什么是默认值,就可以了。
十五、redo log 和 binlog 的区别
这是最高频的追问之一,直接记这张表:
| 对比项 | redo log | binlog |
|---|---|---|
| 层级 | InnoDB 引擎层 | Server 层 |
| 内容 | 物理修改 | 逻辑操作 |
| 写法 | 循环写,会覆盖 | 追加写,不覆盖 |
| 主要用途 | 崩溃恢复 | 主从复制、数据恢复 |
一句话总结:
redo log 是 MySQL 写给自己用的(崩溃后自己恢复自己);binlog 是写给"别人"用的(从库要读它同步数据,备份恢复要重放它)。
十六、为什么需要两阶段提交?
现在 MySQL 里有两套日志:
redo log(InnoDB引擎层)
binlog(Server层)
一次事务提交,两份都要写。
如果先写一份、写完另一份之前崩溃了,会怎样?
情况1:先写 redo log,后写 binlog
redo log写完(张三 1000 → 500)
↓
崩溃,binlog还没写
↓
主库恢复:重放redo log
↓
张三 = 500 ✅
从库:binlog里没有这条记录
↓
张三 = 1000 ❌
主从不一致
情况2:先写 binlog,后写 redo log
binlog写完(张三 1000 → 500)
↓
崩溃,redo log还没写
↓
主库恢复:没有redo log
↓
事务回滚
↓
张三 = 1000 ❌
从库:重放binlog
↓
张三 = 500 ❌(从库多执行了一个主库没有的事务)
主从又不一致
结论:
不管谁先谁后
↓
中间崩溃都可能导致两份日志不一致
↓
所以需要两阶段提交
十七、两阶段提交流程
事务提交时:
COMMIT
↓
① redo log写入磁盘,标记为 prepare
↓
② 写 binlog 并落盘
↓
③ redo log 标记为 commit
图:
┌──────────────┐
│ prepare │ ← 第一阶段
└──────┬───────┘
↓
┌──────────────┐
│ 写 binlog │
└──────┬───────┘
↓
┌──────────────┐
│ commit │ ← 第二阶段
└──────────────┘
注意理解:
两阶段提交指的是"一个事务的提交分成两个阶段",不是两个事务。
十八、崩溃恢复怎么判断?
MySQL 崩溃重启后,扫描 redo log:
redo log 已经是 commit 状态
↓
直接恢复提交 ✅
redo log 处于 prepare 状态
↓
去查binlog:这个事务的记录完整吗?
↙ ↘
完整 不完整
↓ ↓
提交 ✅ 回滚 ❌
为什么这样判断:
binlog完整
↓
说明这次修改已经可以被从库拿到
↓
主库也提交
↓
两边一致
binlog不完整
↓
从库不会执行这个事务
↓
主库也回滚
↓
两边都当它没发生过
十九、一条 UPDATE 的完整流程
现在把整个 MySQL 系列串起来。执行:
UPDATE account
SET balance = 500
WHERE id = 1;
完整过程:
1. 通过索引(B+ Tree)定位 id = 1 的记录
(串联:索引篇)
2. 对记录加锁
(串联:锁机制篇,这里是Record Lock)
3. 写 undo log
记录 500 → 1000 的反操作
(回滚用 + MVCC版本链用)
4. 在 Buffer Pool 中修改数据页
产生脏页
5. 写 redo log buffer
记录页级别的物理修改
6. 写 binlog cache
(事务执行中先写在内存里)
7. COMMIT:两阶段提交
redo log prepare
→ binlog落盘
→ redo log commit
8. 后台线程收尾
异步刷脏页
purge线程清理不再需要的undo log
一图总览:
UPDATE
↓
索引定位 → 加锁 → 写undo → 改Buffer Pool → 写redo → 写binlog → 两阶段提交
↓
脏页
↓
后台异步刷盘
以前学的知识现在全部有了位置:
索引 → 第1步怎么快速定位
锁 → 第2步怎么控制并发
undo → 第3步怎么回滚、怎么读旧版本
redo → 第5步怎么保证不丢
binlog → 第6步怎么给从库和备份用
二十、双 1 配置(工作知识)
生产环境常说的"双1":
innodb_flush_log_at_trx_commit = 1
sync_binlog = 1
含义:
每次事务提交
↓
redo log fsync 到磁盘
+
binlog fsync 到磁盘
↓
最安全
↓
但每次提交都有刷盘开销
sync_binlog 的取值:
= 1 每次提交都fsync(最安全)
= 0 交给操作系统决定什么时候刷
= N 攒N个事务fsync一次
非核心业务(比如日志表、统计表),有时会放宽这两个参数换取性能。
🎯 面试追问
Q1:MySQL 有哪些日志?
答:
核心是三大日志:
undo log(回滚 + MVCC)
redo log(崩溃恢复)
binlog(主从复制 + 数据恢复)
此外还有错误日志、慢查询日志(学 Explain 和索引优化时用过它定位慢SQL)、中继日志(主从复制时从库用的)等。
Q2:redo log 和 binlog 有什么区别?
答:
层级:redo log是InnoDB引擎层,binlog是Server层
内容:redo log是物理修改,binlog是逻辑操作
写法:redo log循环写会覆盖,binlog追加写不覆盖
用途:redo log用于崩溃恢复,binlog用于主从复制和数据恢复
Q3:什么是 WAL?
答:
Write-Ahead Logging
=
先写日志,再刷数据页
本质:
用顺序写的日志
↓
代替(推迟)
↓
随机写的数据页
Q4:有了 binlog,为什么还要 redo log?
答:
三个角度:
1. binlog是Server层的日志
没有crash-safe能力
InnoDB需要自己的日志保证持久性
2. binlog不知道数据页的状态
无法高效地恢复"哪些页改了但还没刷盘"
3. redo log是物理日志
重放时直接定位到页
恢复效率高
Q5:undo log 是什么时候删除的?
答:
不是事务提交就删。
可能还有其他事务的Read View
需要通过版本链读旧版本
↓
由purge线程确认
没有任何活跃事务需要旧版本后
↓
才清理
Q6:undo log 和 MVCC 是什么关系?
答:
undo log保存旧版本信息
↓
通过roll_pointer串成版本链
↓
配合Read View做可见性判断
↓
实现快照读
Q7:什么是两阶段提交?为什么需要?
答:
prepare → 写binlog → commit
因为 redo log 和 binlog 是两套独立日志,无论谁先写完崩溃,都可能导致主从不一致。两阶段提交保证两份日志的逻辑一致。
Q8:崩溃恢复时,prepare 状态的事务怎么处理?
答:
查binlog中这个事务的记录是否完整
完整 → 提交
不完整 → 回滚
Q9:innodb_flush_log_at_trx_commit 的三个值有什么区别?
答:
1:每次提交fsync,最安全
0:只写redo log buffer,每秒刷,可能丢1秒
2:写到OS cache,每秒fsync
MySQL崩了不丢,操作系统崩了才丢
Q10:什么是"双1"?
答:
innodb_flush_log_at_trx_commit = 1
sync_binlog = 1
每次提交 redo log 和 binlog 都落盘,安全性最高。
Q11:redo log 写满了会怎样?
答:
write pos追上check point
↓
阻塞更新
↓
强制推进check point(刷脏页)
↓
腾出空间后继续
redo log 太小会导致频繁写满、周期性卡顿。
Q12:binlog 有哪几种格式?
答:
STATEMENT:记SQL语句,量小但可能主从不一致
ROW:记行变更,准确但量大(默认)
MIXED:默认STATEMENT,不安全时自动用ROW
Q13:长事务有什么危害?
答(现在能答出两个层面):
锁层面:
长时间持锁 → 其他事务锁等待
undo层面:
旧版本一直被引用 → undo log无法purge → 表空间膨胀
Q14:什么是脏页?什么时候刷?
答:
内存里改过、磁盘上还没刷的页
刷盘时机:
redo log写满时
内存不足需要淘汰页时
MySQL正常关闭时
后台线程定期刷
Q15:什么是组提交(group commit)?
答:
多个并发事务提交时
↓
把各自的fsync合并成一次
↓
摊薄每个事务的刷盘开销
是"双1"配置下仍能撑住高并发的重要优化。
🔗 知识串联
你之前学过:
索引
↓
Explain / 索引优化
↓
事务隔离级别
↓
MVCC + Read View
↓
锁机制
今天补上:
undo log / redo log / binlog
↓
两阶段提交
现在事务的三大特性都有了着落:
MySQL 事务
↓
┌────────────┼────────────┐
↓ ↓ ↓
原子性 隔离性 持久性
↓ ↓ ↓
undo log MVCC + 锁 redo log
↓ Read View ↓
回滚 Next-Key 崩溃恢复
↓ Lock ↓
MVCC版本链 两阶段提交
↔ binlog
↓
主从复制 / 数据恢复
一条 UPDATE 的完整链路(第十九节)把全部知识串成了一根线:
索引定位 → 加锁 → 写undo → 改Buffer Pool → 写redo → 写binlog → 两阶段提交 → 异步刷脏页
⚠️ 易错点
1. binlog 没有 crash-safe 能力
能做崩溃恢复的只有 InnoDB 的 redo log。
不要说"binlog 也能恢复所以 redo log 多余"。
binlog 的"恢复"指的是全量备份 + 重放,和崩溃恢复是两回事。
2. undo log 不是提交就删
要等 purge 线程确认没有事务再需要旧版本。
3. 写入方向别说反
redo log:循环写,会覆盖
binlog :追加写,不覆盖
4. 内容类型别说反
redo log:物理日志
binlog :逻辑日志
5. 两阶段提交不是"两个事务"
是"一个事务的提交过程分成两个阶段"。
6. STATEMENT 格式的主从不一致要能举例
UPDATE user
SET name = 'a'
WHERE create_time > now()
LIMIT 10;
主库和从库执行时 now() 可能不同、LIMIT 的行顺序也可能不同,结果就可能不一致。
7. 长事务的危害是双重的
锁等待(锁机制篇)
undo无法清理(本篇)
❓ 自测
-
MySQL 三大日志是什么?分别属于哪一层?
-
为什么修改数据不直接写磁盘?
-
什么是 WAL?
-
什么是 Buffer Pool?什么是脏页?
-
redo log 记录的是什么内容?
-
redo log 的核心作用是什么?保证哪个事务特性?
-
为什么顺序写比随机写快?
-
redo log 是循环写还是追加写?
-
write pos 和 check point 分别是什么?
-
redo log 写满了会发生什么?
-
innodb_flush_log_at_trx_commit 三个值有什么区别?
-
undo log 记录的是什么内容?
-
undo log 的两大作用是什么?
-
undo log 和 MVCC 版本链是什么关系?
-
undo log 什么时候被清理?由谁清理?
-
binlog 的两大用途是什么?
-
binlog 有哪三种格式?默认是哪种?
-
redo log 和 binlog 有哪几个核心区别?
-
如果先写 redo log 后写 binlog,中间崩溃会怎样?
-
如果先写 binlog 后写 redo log,中间崩溃会怎样?
-
两阶段提交的三个步骤是什么?
-
崩溃恢复时,prepare 状态的事务如何决定提交还是回滚?
-
一条 UPDATE 语句从定位到提交的完整流程是什么?
-
什么是"双1"配置?
-
长事务有哪些危害?