qinyelin
发布于 2026-11-16 / 1 阅读
0
0

MySQL 三大日志

MySQL 三大日志:undo log、redo log 与 binlog

面试频率:★★★★★
工作频率:★★★★☆
学习重点:三种日志各自解决什么问题、WAL 思想,以及两阶段提交


⚡ 30 秒速记

三大日志一句话:

undo log(回滚日志)
    ↓
记录"怎么改回去"
    ↓
事务回滚 + MVCC 历史版本

redo log(重做日志)
    ↓
记录"数据页改了什么"
    ↓
崩溃恢复,保证持久性

binlog(归档日志)
    ↓
记录"执行了哪些操作"
    ↓
主从复制 + 数据恢复

一张表记住区别:

日志所在层内容主要作用写入方式
undo logInnoDB 引擎层逻辑反操作回滚、MVCC 版本链随事务产生
redo logInnoDB 引擎层物理修改崩溃恢复循环写
binlogServer 层逻辑操作主从复制、数据恢复追加写

最重要的思想:

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 logbinlog
层级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无法清理(本篇)

❓ 自测

  1. MySQL 三大日志是什么?分别属于哪一层?

  2. 为什么修改数据不直接写磁盘?

  3. 什么是 WAL?

  4. 什么是 Buffer Pool?什么是脏页?

  5. redo log 记录的是什么内容?

  6. redo log 的核心作用是什么?保证哪个事务特性?

  7. 为什么顺序写比随机写快?

  8. redo log 是循环写还是追加写?

  9. write pos 和 check point 分别是什么?

  10. redo log 写满了会发生什么?

  11. innodb_flush_log_at_trx_commit 三个值有什么区别?

  12. undo log 记录的是什么内容?

  13. undo log 的两大作用是什么?

  14. undo log 和 MVCC 版本链是什么关系?

  15. undo log 什么时候被清理?由谁清理?

  16. binlog 的两大用途是什么?

  17. binlog 有哪三种格式?默认是哪种?

  18. redo log 和 binlog 有哪几个核心区别?

  19. 如果先写 redo log 后写 binlog,中间崩溃会怎样?

  20. 如果先写 binlog 后写 redo log,中间崩溃会怎样?

  21. 两阶段提交的三个步骤是什么?

  22. 崩溃恢复时,prepare 状态的事务如何决定提交还是回滚?

  23. 一条 UPDATE 语句从定位到提交的完整流程是什么?

  24. 什么是"双1"配置?

  25. 长事务有哪些危害?


评论