MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解------InnoDB 如何实现事务隔离?

🔥 星恒随风: 个人主页 ❄️ 个人专栏: 《Linux网络编程从0到1》 | 《C语言基础》 | 《数据结构和算法》 | 《MySQL入门心法》 | 《前端基础》 | 《python基础》 | 《C++从入门到入土》 | 《Linux系统编程》 ✨ 数据即知识,压缩即智能
文章目录
- [MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解------InnoDB 如何实现事务隔离?](#MySQL 从零入门(十):MVCC、Undo Log 与 Read View 详解——InnoDB 如何实现事务隔离?)
- 一、如何进一步理解事务隔离性?
-
- [1.1 数据库为什么需要并发控制?](#1.1 数据库为什么需要并发控制?)
- [1.2 读---读](#1.2 读—读)
- [1.3 读---写](#1.3 读—写)
- [1.4 写---写](#1.4 写—写)
- [二、什么是 MVCC?](#二、什么是 MVCC?)
-
- [2.1 MVCC 的基本概念](#2.1 MVCC 的基本概念)
- [2.2 MVCC 的作用](#2.2 MVCC 的作用)
- 三、当前读与快照读
-
- [3.1 什么是快照读?](#3.1 什么是快照读?)
- [3.2 什么是当前读?](#3.2 什么是当前读?)
- [3.3 快照读与当前读的区别](#3.3 快照读与当前读的区别)
- [四、InnoDB 记录中的隐藏字段](#四、InnoDB 记录中的隐藏字段)
-
- [4.1 为什么需要隐藏字段?](#4.1 为什么需要隐藏字段?)
- [4.2 DB_TRX_ID](#4.2 DB_TRX_ID)
- [4.3 DB_ROLL_PTR](#4.3 DB_ROLL_PTR)
- [4.4 DB_ROW_ID](#4.4 DB_ROW_ID)
- [4.5 隐藏字段示意](#4.5 隐藏字段示意)
- [五、Undo Log:回滚日志](#五、Undo Log:回滚日志)
-
- [5.1 什么是 Undo Log?](#5.1 什么是 Undo Log?)
- [5.2 Undo Log 的两个主要作用](#5.2 Undo Log 的两个主要作用)
- [5.3 Undo Log 存储在哪里?](#5.3 Undo Log 存储在哪里?)
- [5.4 Undo Log 与 Redo Log 的区别](#5.4 Undo Log 与 Redo Log 的区别)
- [六、Undo Log 如何构建版本链?](#六、Undo Log 如何构建版本链?)
-
- [6.1 初始记录](#6.1 初始记录)
- [6.2 第一次修改](#6.2 第一次修改)
- [6.3 第二次修改](#6.3 第二次修改)
- [6.4 为什么需要版本链?](#6.4 为什么需要版本链?)
- [七、INSERT、UPDATE、DELETE 与 Undo Log](#七、INSERT、UPDATE、DELETE 与 Undo Log)
-
- [7.1 UPDATE](#7.1 UPDATE)
- [7.2 DELETE](#7.2 DELETE)
- [7.3 INSERT](#7.3 INSERT)
- [7.4 Undo Log 会一直保存吗?](#7.4 Undo Log 会一直保存吗?)
- [八、Read View:读视图](#八、Read View:读视图)
-
- [8.1 什么是 Read View?](#8.1 什么是 Read View?)
- [8.2 Read View 的主要信息](#8.2 Read View 的主要信息)
- [8.3 Read View 示意图](#8.3 Read View 示意图)
- [九、Read View 如何判断版本可见性?](#九、Read View 如何判断版本可见性?)
-
- [9.1 假设存在多个事务](#9.1 假设存在多个事务)
- [9.2 第一种情况:版本由当前事务自己产生](#9.2 第一种情况:版本由当前事务自己产生)
- [9.3 第二种情况:事务 ID 小于最小活跃事务 ID](#9.3 第二种情况:事务 ID 小于最小活跃事务 ID)
- [9.4 第三种情况:事务 ID 大于等于上界](#9.4 第三种情况:事务 ID 大于等于上界)
- [9.5 第四种情况:事务 ID 处于中间区间](#9.5 第四种情况:事务 ID 处于中间区间)
- [9.6 可见性判断流程](#9.6 可见性判断流程)
- [十、Read View 与版本链如何配合?](#十、Read View 与版本链如何配合?)
-
- [10.1 判断最新版本 v3](#10.1 判断最新版本 v3)
- [10.2 判断 v2](#10.2 判断 v2)
- [10.3 判断 v1](#10.3 判断 v1)
- [十一、READ COMMITTED 与 REPEATABLE READ 的本质区别](#十一、READ COMMITTED 与 REPEATABLE READ 的本质区别)
-
- [11.1 READ COMMITTED](#11.1 READ COMMITTED)
- [11.2 REPEATABLE READ](#11.2 REPEATABLE READ)
- [11.3 两者对比](#11.3 两者对比)
- [十二、实验:观察 READ COMMITTED 的 Read View 行为](#十二、实验:观察 READ COMMITTED 的 Read View 行为)
-
- [12.1 创建测试表](#12.1 创建测试表)
- [12.2 设置 READ COMMITTED](#12.2 设置 READ COMMITTED)
- [12.3 事务 A 第一次查询](#12.3 事务 A 第一次查询)
- [12.4 事务 B 修改数据](#12.4 事务 B 修改数据)
- [12.5 事务 A 第二次查询](#12.5 事务 A 第二次查询)
- [十三、实验:观察 REPEATABLE READ 的行为](#十三、实验:观察 REPEATABLE READ 的行为)
-
- [13.1 恢复测试数据](#13.1 恢复测试数据)
- [13.2 事务 A 第一次查询](#13.2 事务 A 第一次查询)
- [13.3 事务 B 修改数据](#13.3 事务 B 修改数据)
- [13.4 事务 A 再次查询](#13.4 事务 A 再次查询)
- [13.5 提交后重新查询](#13.5 提交后重新查询)
- [十四、为什么 BEGIN 的执行时机很重要?](#十四、为什么 BEGIN 的执行时机很重要?)
-
- [14.1 场景一:BEGIN 后先查询](#14.1 场景一:BEGIN 后先查询)
- [14.2 场景二:BEGIN 后暂时不查询](#14.2 场景二:BEGIN 后暂时不查询)
- [14.3 如何在事务开始时建立一致性快照?](#14.3 如何在事务开始时建立一致性快照?)
- [十五、REPEATABLE READ 下的当前读与快照读](#十五、REPEATABLE READ 下的当前读与快照读)
-
- [15.1 普通 SELECT 属于快照读](#15.1 普通 SELECT 属于快照读)
- [15.2 SELECT FOR UPDATE 属于当前读](#15.2 SELECT FOR UPDATE 属于当前读)
- [15.3 实验:同一个事务内两种读的结果不同](#15.3 实验:同一个事务内两种读的结果不同)
- [十六、MVCC 如何影响幻读?](#十六、MVCC 如何影响幻读?)
-
- [16.1 普通快照读](#16.1 普通快照读)
- [16.2 当前读](#16.2 当前读)
- [16.3 为什么仍要区分快照读与当前读?](#16.3 为什么仍要区分快照读与当前读?)
- [十七、MVCC 能解决写---写冲突吗?](#十七、MVCC 能解决写—写冲突吗?)
-
- [17.1 什么是丢失更新?](#17.1 什么是丢失更新?)
- [17.2 如何降低丢失更新风险?](#17.2 如何降低丢失更新风险?)
- [十八、从 C++ 后端开发理解事务与 MVCC](#十八、从 C++ 后端开发理解事务与 MVCC)
-
- [18.1 尽量缩短事务生命周期](#18.1 尽量缩短事务生命周期)
- [18.2 一次事务应使用同一数据库连接](#18.2 一次事务应使用同一数据库连接)
- [18.3 发生异常时必须处理事务状态](#18.3 发生异常时必须处理事务状态)
- [18.4 不要把 MVCC 当作万能的并发控制机制](#18.4 不要把 MVCC 当作万能的并发控制机制)
- 十九、常见问题总结
-
- [19.1 MVCC 是不是完全无锁?](#19.1 MVCC 是不是完全无锁?)
- [19.2 Undo Log 是否只保存在内存?](#19.2 Undo Log 是否只保存在内存?)
- [19.3 DB_ROW_ID 是否一定存在?](#19.3 DB_ROW_ID 是否一定存在?)
- [19.4 为什么历史版本不会立即删除?](#19.4 为什么历史版本不会立即删除?)
- [19.5 Read View 是完整的数据副本吗?](#19.5 Read View 是完整的数据副本吗?)
- [19.6 为什么 READ COMMITTED 可能不可重复读?](#19.6 为什么 READ COMMITTED 可能不可重复读?)
- [19.7 为什么 REPEATABLE READ 可以保持快照稳定?](#19.7 为什么 REPEATABLE READ 可以保持快照稳定?)
- [19.8 BEGIN 是否立即创建 Read View?](#19.8 BEGIN 是否立即创建 Read View?)
- [19.9 为什么 SELECT FOR UPDATE 能读取新版本?](#19.9 为什么 SELECT FOR UPDATE 能读取新版本?)
- [19.10 MVCC 可以解决所有幻读吗?](#19.10 MVCC 可以解决所有幻读吗?)
- 二十、知识点速查表
- 二十一、总结
前言
上一篇《MySQL 从零入门(九·上):事务管理详解》中,我们学习了事务的 ACID 四大特性,以及四种事务隔离级别。
其中最值得思考的是 MySQL 的可重复读。
假设数据库中存在:
text
id = 1
name = 张三
age = 18
事务 A 执行:
sql
BEGIN;
SELECT * FROM student WHERE id = 1;
读取到:
text
张三 18
随后,事务 B 将年龄修改为 20:
sql
BEGIN;
UPDATE student
SET age = 20
WHERE id = 1;
COMMIT;
此时事务 B 已经提交。
但是,事务 A 如果仍然处于 REPEATABLE READ 隔离级别,并且继续执行普通 SELECT:
sql
SELECT * FROM student WHERE id = 1;
通常仍然能够看到:
text
张三 18
这里出现了几个问题:
- 数据库明明已经修改,为什么事务 A 还能读取旧数据?
- InnoDB 是否同时保存了多个版本?
- 旧版本数据保存在哪里?
- MySQL 如何判断某个事务应该看到哪个版本?
- 为什么 READ COMMITTED 与 REPEATABLE READ 的读取结果不同?
答案与 MVCC(Multi-Version Concurrency Control,多版本并发控制) 有关。
本文将从事务并发问题出发,逐步介绍 Undo Log、记录隐藏字段、版本链以及 Read View 的工作机制。
一、如何进一步理解事务隔离性?
1.1 数据库为什么需要并发控制?
MySQL 是一个数据库服务器。
在实际项目中,可能有大量客户端同时发送请求。
例如:
text
客户端 A ──┐
│
客户端 B ──┤
├── MySQL Server
客户端 C ──┤
│
客户端 D ──┘
不同客户端可能同时:
- 查询同一条记录。
- 修改同一条记录。
- 删除某条记录。
- 插入新记录。
如果不控制并发行为,就可能出现数据竞争和一致性问题。
可以按照操作类型,将并发访问分成三种情况:
| 并发情况 | 主要问题 |
|---|---|
| 读---读 | 普通一致性读之间通常不需要互相阻塞 |
| 读---写 | 可能出现脏读、不可重复读、幻读 |
| 写---写 | 可能出现写冲突、锁等待、丢失更新等问题 |
1.2 读---读
假设事务 A 和事务 B 都执行:
sql
SELECT *
FROM student
WHERE id = 1;
它们只读取数据,没有修改记录。
在 InnoDB 的普通一致性读场景中,两个事务通常可以并发读取,不需要因为读取同一行而相互等待。
1.3 读---写
事务 A 查询:
sql
SELECT *
FROM student
WHERE id = 1;
事务 B 更新:
sql
UPDATE student
SET age = 20
WHERE id = 1;
现在问题是:
A 应该读取修改前的数据,还是修改后的数据?
如果 B 尚未提交,A 是否应该读取其修改?
这就是事务隔离性需要解决的问题。
1.4 写---写
事务 A:
sql
UPDATE student
SET age = 20
WHERE id = 1;
事务 B:
sql
UPDATE student
SET age = 25
WHERE id = 1;
两个事务同时修改同一条记录。
InnoDB 通常通过行级锁等机制协调这些写入。
需要注意:
MVCC 主要用于提高一致性读与写操作的并发能力,并不能单独解决所有写---写冲突。
因此,InnoDB 的事务隔离需要 MVCC 和锁机制共同完成。
二、什么是 MVCC?
2.1 MVCC 的基本概念
MVCC 全称:
Multi-Version Concurrency Control
中文名称:
多版本并发控制。
其核心思想是:
通过维护数据的多个历史版本,让不同事务按照自己的可见性规则读取相应版本。
例如,一条学生记录经历了三次修改:
text
版本 v1:
张三 18
版本 v2:
张三 20
版本 v3:
张三 22
最新版本是:
text
张三 22
但是,不同事务可能需要读取不同版本。
例如:
text
事务 A → 读取 v1
事务 B → 读取 v2
事务 C → 读取 v3
这样,数据库在处理更新操作时,不需要让所有普通读取都等待最新写入完成。
2.2 MVCC 的作用
MVCC 的主要价值包括:
- 提供数据的历史可见版本。
- 实现一致性快照读。
- 降低普通读操作和写操作之间的阻塞。
- 为 READ COMMITTED 和 REPEATABLE READ 提供重要支持。
需要注意:
MVCC 并不意味着完全不使用锁。
例如:
sql
UPDATE ...
sql
DELETE ...
sql
SELECT ... FOR UPDATE
仍然涉及锁定和当前数据访问。
三、当前读与快照读
在理解 MVCC 之前,首先需要区分两个概念:
- 当前读(Current Read)
- 快照读(Snapshot Read)
3.1 什么是快照读?
在 InnoDB 的 READ COMMITTED 和 REPEATABLE READ 隔离级别下,普通 SELECT 通常是一致性非锁定读,也就是常说的快照读。
例如:
sql
SELECT *
FROM student
WHERE id = 1;
快照读根据事务的可见性规则,选择一个可以读取的记录版本。
这个版本可能是当前最新已提交版本,也可能是历史版本。
例如:
text
最新数据:age = 22
事务 A 的快照:age = 18
那么事务 A 的普通 SELECT 可能仍然返回:
text
age = 18
注意,快照读不代表一定读取旧版本,而是读取对当前事务可见的版本。
3.2 什么是当前读?
当前读需要基于当前能够访问和锁定的记录状态执行操作。
典型语句包括:
sql
SELECT *
FROM student
WHERE id = 1
FOR UPDATE;
以及:
sql
SELECT *
FROM student
WHERE id = 1
LOCK IN SHARE MODE;
还有:
sql
UPDATE student
SET age = 20
WHERE id = 1;
sql
DELETE FROM student
WHERE id = 1;
这些操作需要依据当前记录状态进行读取或修改。
如果目标记录被其他事务锁定,当前事务可能需要等待。
3.3 快照读与当前读的区别
| 特性 | 快照读 | 当前读 |
|---|---|---|
| 常见操作 | 普通 SELECT | 锁定 SELECT、UPDATE、DELETE |
| 读取版本 | 按 Read View 选择可见版本 | 访问当前可锁定的记录状态 |
| 是否通常需要对读取行加锁 | 不需要 | 通常需要 |
| 是否可能读取历史版本 | 可以 | 不是以历史快照作为主要读取依据 |
| 核心机制 | MVCC | 锁机制及当前记录访问 |
需要注意,当前读遇到其他事务未提交的修改时,也不能随意读取脏数据,而是需要遵守相应的锁定与隔离规则。
四、InnoDB 记录中的隐藏字段
4.1 为什么需要隐藏字段?
我们创建一张表:
sql
CREATE TABLE student (
name VARCHAR(20) NOT NULL,
age INT NOT NULL
) ENGINE=InnoDB;
执行:
sql
DESC student;
只能看到:
text
name
age
但是 InnoDB 内部管理记录时,还需要保存一些额外信息。
其中与 MVCC 密切相关的是:
- DB_TRX_ID
- DB_ROLL_PTR
- DB_ROW_ID
4.2 DB_TRX_ID
DB_TRX_ID 通常占用 6 字节。
它用于记录最近一次插入或修改该聚簇索引记录的事务 ID。
可以理解为:
text
这条记录的当前版本是由哪个事务产生的?
例如:
text
name = 李四
age = 28
DB_TRX_ID = 10
表示该记录当前版本由事务 10 产生。
这里的事务编号 10 只是用于解释原理的示例值。
实际事务 ID 由 InnoDB 内部管理。
4.3 DB_ROLL_PTR
DB_ROLL_PTR 通常占用 7 字节。
它是回滚指针,用来关联记录对应的 Undo Log 信息。
通过这一指针,InnoDB 可以访问相关历史版本。
例如:
text
当前版本
│
│ DB_ROLL_PTR
▼
上一个历史版本
需要注意,它并不是简单的 C/C++ 裸内存指针,而是 InnoDB 内部使用的回滚记录定位信息。
4.4 DB_ROW_ID
DB_ROW_ID 是 InnoDB 内部可能使用的隐藏行 ID,通常占用 6 字节。
当一张表没有显式主键,也没有适合作为聚簇索引的非空唯一索引时,InnoDB 可以使用内部生成的行 ID 来组织聚簇索引。
因此:
并不是每条 InnoDB 记录都一定需要使用 DB_ROW_ID 作为隐藏主键。
如果表已经有合适的显式主键,聚簇索引通常直接使用该主键。
4.5 隐藏字段示意
假设表中保存:
text
name = 张三
age = 28
从逻辑上,可以这样理解:
text
┌────────┬─────┬───────────┬─────────────┐
│ name │ age │ DB_TRX_ID │ DB_ROLL_PTR │
├────────┼─────┼───────────┼─────────────┤
│ 张三 │ 28 │ 10 │ ... │
└────────┴─────┴───────────┴─────────────┘
隐藏字段不是我们在普通 SELECT 中直接查询的业务列。
它们由 InnoDB 在存储引擎内部使用。
五、Undo Log:回滚日志
5.1 什么是 Undo Log?
Undo Log 是 InnoDB 用于支持事务回滚以及构建一致性读取历史版本的重要日志机制。
例如,原记录:
text
张三 28
事务 A 执行:
sql
UPDATE student
SET age = 38
WHERE name = '张三';
为了支持事务回滚和多版本读取,InnoDB 需要保留能够恢复旧版本所需的信息。
这些信息与 Undo Log 有关。
5.2 Undo Log 的两个主要作用
第一:支持事务回滚。
如果事务还没有提交:
sql
ROLLBACK;
InnoDB 可以利用相关 Undo 信息撤销事务修改。
第二:支持 MVCC 的历史版本访问。
即使一个事务已经提交,它产生的旧版本信息也可能暂时不能清理。
原因是其他尚未结束的事务可能还需要读取这些旧版本。
5.3 Undo Log 存储在哪里?
Undo Log 不是仅仅存在于某个内存缓冲区中的临时数据。
InnoDB 会通过 Undo 页面和相应表空间等持久化结构管理这些信息。
相关页面也可能进入内存缓存。
因此,不能将 Undo Log 简单理解为"只保存在内存中的历史数据"。
5.4 Undo Log 与 Redo Log 的区别
| 日志 | 主要作用 |
|---|---|
| Undo Log | 支持回滚和历史版本读取 |
| Redo Log | 支持已提交修改的持久性与崩溃恢复 |
| Binlog | 服务器层面的逻辑变更日志,常用于复制和恢复 |
简单理解:
text
Undo Log:如何撤销或者访问以前的版本?
Redo Log:崩溃后如何重做需要恢复的修改?
Binlog:数据库发生过哪些需要记录的逻辑变更?
这三者的工作机制和使用场景并不完全相同。
六、Undo Log 如何构建版本链?
这是 MVCC 最重要的知识点之一。

图 1:Undo Log 历史版本链。来源:GreatDB《图文结合带你搞懂 InnoDB MVCC 机制》。
6.1 初始记录
假设:
sql
CREATE TABLE student_version (
id INT PRIMARY KEY,
name VARCHAR(20),
age INT
) ENGINE=InnoDB;
插入:
sql
INSERT INTO student_version
VALUES (1, '张三', 28);
可以将初始状态简化为:
text
版本 v1
id = 1
name = 张三
age = 28
这里暂时不考虑实际事务 ID 的具体取值。
6.2 第一次修改
假设事务 10 将:
text
name = 张三
修改为:
text
name = 李四
执行:
sql
BEGIN;
UPDATE student_version
SET name = '李四'
WHERE id = 1;
COMMIT;
InnoDB 内部通过 Undo 信息支持旧版本的恢复。
可以简化为:
text
当前版本 v2
李四 28
DB_TRX_ID = 10
│
│ DB_ROLL_PTR
▼
历史版本 v1
张三 28
现在最新记录是:
text
李四 28
但旧版本的信息仍可能被需要历史快照的事务使用。
6.3 第二次修改
假设事务 11 将年龄从 28 改为 38。
sql
BEGIN;
UPDATE student_version
SET age = 38
WHERE id = 1;
COMMIT;
现在形成:
text
当前版本 v3
李四 38
DB_TRX_ID = 11
│
▼
历史版本 v2
李四 28
DB_TRX_ID = 10
│
▼
历史版本 v1
张三 28
这就是一个简化的记录版本链。
需要注意,真实的 Undo Log 保存的是能够用于恢复历史状态的回滚信息,并不一定按照图中这种完整行副本的形式存储每一个版本。
因此,版本链图主要用于解释逻辑关系。
6.4 为什么需要版本链?
假设存在两个事务:
text
事务 A:需要读取 v1
事务 B:已经提交 v3
如果数据库只保留 v3,事务 A 就无法继续读取旧快照。
而版本链使 InnoDB 有机会沿着历史信息查找:
text
v3 → v2 → v1
并找到当前事务允许读取的版本。
这正是 MVCC 的基础。
七、INSERT、UPDATE、DELETE 与 Undo Log
7.1 UPDATE
UPDATE 修改已有记录。
因此,通常需要保存能够恢复旧值的信息。
同时,更新还可能形成供 MVCC 读取的历史版本。
7.2 DELETE
DELETE 在 InnoDB 中通常涉及删除标记及后续清理机制。
例如:
sql
DELETE FROM student_version
WHERE id = 1;
对于仍被其他事务的历史快照需要的记录,不能简单地立即清除全部历史信息。
因此,删除操作也会涉及 Undo 信息和版本可见性。
7.3 INSERT
INSERT 创建此前不存在的新记录。
因此,它通常没有同一记录的旧行版本。
但是为了支持事务回滚,INSERT 仍需要相应的 Undo 信息。
例如:
sql
BEGIN;
INSERT INTO student_version
VALUES (2, '王五', 20);
ROLLBACK;
插入的记录将被撤销。
7.4 Undo Log 会一直保存吗?
不会。
如果相关历史版本已经不再被需要,InnoDB 可以通过 Purge 等机制逐步清理不再需要的历史记录。
但是,如果存在长期未结束的一致性读事务,就可能延长相关历史版本需要保留的时间。
因此,长事务可能造成 Undo 历史堆积。
这也是实际后端开发中不建议长时间保持事务开启的重要原因之一。
八、Read View:读视图
现在我们已经知道:
一条记录可能拥有多个历史版本。
例如:
text
v3 → v2 → v1
但新的问题出现了:
MySQL 如何判断某个事务能够看到哪个版本?
答案是:
text
Read View
8.1 什么是 Read View?
Read View 是 InnoDB 在执行一致性读时,用于判断记录版本可见性的内部数据结构。
可以将它理解为:
描述某个一致性读视角下事务可见性状态的信息。
当执行普通 SELECT 时,InnoDB 根据适用的 Read View 判断应该返回哪个版本。
需要注意,Read View 本身并不是把数据库中的所有记录完整复制一份。
它主要保存事务可见性判断所需的信息。
8.2 Read View 的主要信息
在介绍机制时,可以重点关注四类信息:
| 字段或概念 | 含义 |
|---|---|
| creator_trx_id | 创建当前读视图的事务 ID |
| m_ids | 创建视图时相关活跃事务的 ID 列表 |
| min_trx_id | 活跃事务 ID 的下界 |
| max_trx_id | 创建视图时用于可见性判断的事务 ID 上界 |
其中 min_trx_id、max_trx_id 是常见教学命名;在 MySQL 5.7 InnoDB 源码讨论中,也可能看到:
text
m_up_limit_id
m_low_limit_id
需要留意命名方向:
m_up_limit_id对应较小的活跃事务 ID 边界。m_low_limit_id对应较大的事务 ID 上界。
不要仅根据字段名称中 up、low 的字面含义判断数值大小。
8.3 Read View 示意图

图 2:Read View 中的事务 ID 信息及记录版本关系。来源:小林coding《事务隔离级别是怎么实现的?》。
Read View 并不是记录"当前数据库全部数据是什么"。
它更重要的作用是:
text
给定某条记录版本的事务 ID
判断这个版本是否对当前一致性读可见
九、Read View 如何判断版本可见性?
9.1 假设存在多个事务
为了方便理解,假设某个 Read View 中:
text
creator_trx_id = 12
m_ids = [11, 13]
min_trx_id = 11
max_trx_id = 14
含义可以理解为:
- 当前读视图由事务 12 创建。
- 事务 11 和事务 13 在创建时仍然活跃。
- 事务 ID 14 及之后的事务不属于该视图已允许观察的更晚事务范围。
这里是逻辑示例,不是实际 SQL 查询输出。
9.2 第一种情况:版本由当前事务自己产生
假设某个版本的:
text
DB_TRX_ID = 12
与:
text
creator_trx_id = 12
相同。
那么它属于当前事务自己的修改。
当前事务通常应该能够读取自己已经执行的修改。
这符合:
Read Your Writes(读己之写)。
9.3 第二种情况:事务 ID 小于最小活跃事务 ID
如果:
text
DB_TRX_ID < min_trx_id
例如:
text
DB_TRX_ID = 10
min_trx_id = 11
那么这个版本由更早的事务产生。
按照该读视图的可见性规则,它对当前读视图可见。
9.4 第三种情况:事务 ID 大于等于上界
如果:
text
DB_TRX_ID >= max_trx_id
例如:
text
DB_TRX_ID = 15
max_trx_id = 14
那么这个版本由创建读视图时尚未进入可见事务范围的事务产生。
因此该版本不可见。
9.5 第四种情况:事务 ID 处于中间区间
如果:
text
min_trx_id <= DB_TRX_ID < max_trx_id
则需要继续判断:
text
DB_TRX_ID 是否在 m_ids 中?
如果存在于活跃事务列表中:
text
不可见
因为这个事务在 Read View 创建时尚未完成提交。
如果不在活跃事务列表中:
text
可见
因为它在创建读视图时已经提交。
9.6 可见性判断流程
可以用下面的伪代码理解:
cpp
bool IsVisible(
TransactionId version_id,
const ReadView& view)
{
// 当前事务自己的修改可见
if (version_id == view.creator_trx_id)
return true;
// 更早的已提交事务版本可见
if (version_id < view.min_trx_id)
return true;
// 创建视图时尚未进入可见范围的事务版本不可见
if (version_id >= view.max_trx_id)
return false;
// 创建视图时仍然活跃的其他事务不可见
if (view.active_ids.contains(version_id))
return false;
// 已提交的其他事务可见
return true;
}
这里是为了理解机制而编写的简化 C++ 伪代码,并不是可以直接编译调用的 MySQL 源码。
真实 InnoDB 还涉及事务 ID 管理、Undo 版本访问及其他内部状态判断。
十、Read View 与版本链如何配合?
假设同一条记录有三个历史版本:
text
版本 v3
name = 王五
DB_TRX_ID = 13
│
▼
版本 v2
name = 李四
DB_TRX_ID = 11
│
▼
版本 v1
name = 张三
DB_TRX_ID = 10
当前 Read View:
text
creator_trx_id = 12
m_ids = [11, 13]
min_trx_id = 11
max_trx_id = 14
现在开始读取。
10.1 判断最新版本 v3
text
DB_TRX_ID = 13
13 在活跃事务列表中。
因此:
text
v3 不可见
继续查找历史版本。
10.2 判断 v2
text
DB_TRX_ID = 11
11 也在活跃事务列表中。
因此:
text
v2 不可见
继续查找。
10.3 判断 v1
text
DB_TRX_ID = 10
而:
text
10 < min_trx_id(11)
因此 v1 可见。
最终返回:
text
张三
整个过程可以概括为:
text
读取最新版本
│
▼
判断 Read View 是否允许访问
│
┌───┴───┐
│ │
可见 不可见
│ │
▼ ▼
返回 沿版本链继续查找
MVCC 的关键是通过 Read View 判断版本可见性,再结合 Undo 历史版本选择正确的记录。
十一、READ COMMITTED 与 REPEATABLE READ 的本质区别
到这里,我们终于可以从底层解释:
为什么读已提交可能出现不可重复读,而可重复读通常能够保持普通查询结果稳定?
核心区别是:
Read View 的创建和复用时机不同。
11.1 READ COMMITTED
在 READ COMMITTED 下:
普通一致性读通常每次执行都会使用新的 Read View。
例如:
text
事务 A 开始
↓
第一次 SELECT
↓
创建 Read View 1
↓
看到 age = 18
事务 B 更新 age = 20
↓
事务 B COMMIT
事务 A 第二次 SELECT
↓
创建 Read View 2
↓
看到 age = 20
因为第二次查询获得了新的读视图,所以能够看到其他事务已经提交的新版本。
11.2 REPEATABLE READ
在 REPEATABLE READ 下:
同一个事务中的普通一致性读通常复用首次一致性读建立的 Read View。
例如:
text
事务 A 开始
↓
第一次 SELECT
↓
创建 Read View 1
↓
看到 age = 18
事务 B 更新 age = 20
↓
事务 B COMMIT
事务 A 第二次 SELECT
↓
继续使用 Read View 1
↓
仍然看到 age = 18
因此,普通一致性读能够保持稳定。
11.3 两者对比
| 对比项 | READ COMMITTED | REPEATABLE READ |
|---|---|---|
| 中文名称 | 读已提交 | 可重复读 |
| Read View | 通常每次一致性读重新创建 | 通常首次一致性读创建后复用 |
| 能否读取其他事务未提交修改 | 否 | 否 |
| 同一事务普通 SELECT 是否可能看到新提交版本 | 可能 | 通常不会 |
| 是否可能发生不可重复读 | 可能 | 普通一致性读可避免 |
| MySQL 5.7 InnoDB 默认 | 否 | 是 |
需要强调:
这里的比较主要针对普通 SELECT 的一致性读。
不能直接推广到所有 UPDATE、DELETE 和锁定读操作。
十二、实验:观察 READ COMMITTED 的 Read View 行为
12.1 创建测试表
创建数据库:
sql
CREATE DATABASE IF NOT EXISTS mvcc_lab
CHARACTER SET utf8;
USE mvcc_lab;
创建表:
sql
CREATE TABLE mvcc_demo (
id INT PRIMARY KEY,
name VARCHAR(20),
age INT
) ENGINE=InnoDB;
插入:
sql
INSERT INTO mvcc_demo
VALUES (1, '张三', 18);
打开两个独立的 mycli 连接,分别作为事务 A 和事务 B。
12.2 设置 READ COMMITTED
两个终端都执行:
sql
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
12.3 事务 A 第一次查询
终端 A:
sql
BEGIN;
SELECT age
FROM mvcc_demo
WHERE id = 1;
返回:
text
18
12.4 事务 B 修改数据
终端 B:
sql
BEGIN;
UPDATE mvcc_demo
SET age = 20
WHERE id = 1;
COMMIT;
现在事务 B 已经提交。
12.5 事务 A 第二次查询
终端 A:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
返回:
text
20
原因是:
READ COMMITTED 下第二次一致性读使用了新的 Read View。
最后:
sql
COMMIT;
结束事务 A。
十三、实验:观察 REPEATABLE READ 的行为
13.1 恢复测试数据
在没有未完成事务的情况下执行:
sql
UPDATE mvcc_demo
SET age = 18
WHERE id = 1;
两个终端分别设置:
sql
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
13.2 事务 A 第一次查询
终端 A:
sql
BEGIN;
SELECT age
FROM mvcc_demo
WHERE id = 1;
返回:
text
18
这次查询建立一致性读快照。
13.3 事务 B 修改数据
终端 B:
sql
BEGIN;
UPDATE mvcc_demo
SET age = 20
WHERE id = 1;
COMMIT;
13.4 事务 A 再次查询
终端 A:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
结果仍然是:
text
18
原因是:
当前事务复用了此前的 Read View。
13.5 提交后重新查询
事务 A:
sql
COMMIT;
再执行:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
返回:
text
20
这说明:
事务结束后,新的一致性读可以看到最新已提交的数据。
十四、为什么 BEGIN 的执行时机很重要?
在 REPEATABLE READ 下,理解 Read View 的建立时机十分重要。
考虑两个场景。
14.1 场景一:BEGIN 后先查询
事务 A:
sql
BEGIN;
SELECT age
FROM mvcc_demo
WHERE id = 1;
假设第一次读到 18。
然后事务 B 更新为 20 并提交。
事务 A 再次执行普通 SELECT:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
通常仍然看到 18。
因为第一次一致性读已经建立快照。
14.2 场景二:BEGIN 后暂时不查询
事务 A:
sql
BEGIN;
但是暂时没有执行一致性读。
此时事务 B:
sql
BEGIN;
UPDATE mvcc_demo
SET age = 20
WHERE id = 1;
COMMIT;
随后事务 A 第一次执行:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
此时通常会看到:
text
20
原因是:
事务 A 虽然已经执行 BEGIN,但之前没有建立普通一致性读的快照。
因此,第一次 SELECT 可以看到此前已提交的事务 B 修改。
14.3 如何在事务开始时建立一致性快照?
可以使用:
sql
START TRANSACTION WITH CONSISTENT SNAPSHOT;
它在 REPEATABLE READ 隔离级别下可以在事务开始时建立一致性快照。
这与普通:
sql
BEGIN;
在快照建立时机上存在区别。
十五、REPEATABLE READ 下的当前读与快照读
这是一个非常容易混淆的知识点。
15.1 普通 SELECT 属于快照读
例如:
sql
SELECT *
FROM mvcc_demo
WHERE id = 1;
在 REPEATABLE READ 下,它通常按照事务的 Read View 读取可见版本。
15.2 SELECT FOR UPDATE 属于当前读
例如:
sql
SELECT *
FROM mvcc_demo
WHERE id = 1
FOR UPDATE;
这是一条锁定读。
它需要读取并锁定当前可访问的记录,而不是简单返回此前快照中的旧版本。
15.3 实验:同一个事务内两种读的结果不同
先确保初始年龄为:
text
18
两个终端都设置 REPEATABLE READ。
终端 A:
sql
BEGIN;
SELECT age
FROM mvcc_demo
WHERE id = 1;
结果:
text
18
终端 B:
sql
BEGIN;
UPDATE mvcc_demo
SET age = 20
WHERE id = 1;
COMMIT;
终端 A:
再次执行普通 SELECT:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1;
结果:
text
18
然后执行:
sql
SELECT age
FROM mvcc_demo
WHERE id = 1
FOR UPDATE;
在 B 已经提交且没有其他冲突锁的情况下,可以看到:
text
20
这是因为:
- 普通 SELECT 使用旧 Read View。
- SELECT FOR UPDATE 进行当前读。
最后:
sql
COMMIT;
释放事务锁。
因此:
同一个 REPEATABLE READ 事务中,快照读与当前读可能观察到不同的数据版本。
十六、MVCC 如何影响幻读?
16.1 普通快照读
假设事务 A 执行:
sql
BEGIN;
SELECT *
FROM mvcc_demo
WHERE age >= 18;
建立快照。
随后事务 B 插入一条符合条件的新记录并提交:
sql
BEGIN;
INSERT INTO mvcc_demo
VALUES (2, '李四', 22);
COMMIT;
事务 A 再次执行相同的普通 SELECT:
sql
SELECT *
FROM mvcc_demo
WHERE age >= 18;
在 REPEATABLE READ 的同一一致性读快照下,通常不会看到事务 B 新插入的记录。
这是因为新记录不属于当前 Read View 可见的版本范围。
16.2 当前读
如果事务 A 执行:
sql
SELECT *
FROM mvcc_demo
WHERE age >= 18
FOR UPDATE;
则属于当前读。
InnoDB 的当前读可能通过记录锁、间隙锁和 Next-Key Lock 等机制,阻止其他事务在相应锁定范围内插入记录。
但是,锁定范围取决于:
- 查询条件。
- 使用的索引。
- 隔离级别。
- 实际执行计划。
因此,不能简单地说所有 SELECT FOR UPDATE 都会锁定整张表。
16.3 为什么仍要区分快照读与当前读?
因为:
text
快照读
↓
根据 Read View 选择可见版本
而:
text
当前读
↓
访问并锁定当前记录或索引范围
两者的可见性和并发控制机制不同。
例如,在某些操作组合中,一个事务可以先通过快照读看不到其他事务新插入的记录,然后通过当前读或者自己对新记录的修改,使后续查询出现不同的结果。
因此,InnoDB 的可重复读能够防止大量典型幻读情况,但不能把"RR 绝对消除了所有幻读"作为不加条件的结论。
十七、MVCC 能解决写---写冲突吗?
不能单独解决。
假设两个事务同时修改:
sql
UPDATE account
SET balance = balance - 100
WHERE id = 1;
InnoDB 需要对相应记录执行写入控制。
如果一个事务已经持有相关排他锁,另一个事务可能需要等待。
因此,写---写冲突主要仍然依赖锁等机制协调。
17.1 什么是丢失更新?
假设账户余额为 1000。
应用程序 A 查询:
text
balance = 1000
应用程序 B 也查询:
text
balance = 1000
随后 A 在应用程序中计算:
text
1000 - 100 = 900
B 也在应用程序中计算:
text
1000 - 200 = 800
如果 A 和 B 分别使用旧值直接覆盖数据库:
sql
UPDATE account
SET balance = 900
WHERE id = 1;
sql
UPDATE account
SET balance = 800
WHERE id = 1;
最终可能只保留其中一次计算结果。
这就是典型的基于旧值计算导致的丢失更新风险。
注意,这与直接执行:
sql
UPDATE account
SET balance = balance - 100
WHERE id = 1;
的数据库端原子更新方式不同。
后者可以在数据库内部基于当前记录进行更新和锁定控制。
17.2 如何降低丢失更新风险?
常见方法包括:
- 使用数据库端原子更新。
- 使用 SELECT FOR UPDATE 锁定记录。
- 使用版本号实现乐观并发控制。
- 正确检查 UPDATE 影响的行数。
例如:
sql
UPDATE account
SET balance = balance - 100
WHERE id = 1
AND balance >= 100;
应用程序应该检查是否成功更新对应行,而不是只判断 SQL 有没有产生语法错误。
十八、从 C++ 后端开发理解事务与 MVCC
在实际 C++ 后端系统中,数据库操作可能通过连接池中的 MySQL 连接执行。
例如用户转账:
text
客户端请求
↓
C++ 后端服务
↓
获取数据库连接
↓
BEGIN
↓
扣除转出方余额
↓
增加转入方余额
↓
COMMIT / ROLLBACK
↓
释放数据库连接
这里有几个非常重要的实践原则。
18.1 尽量缩短事务生命周期
不要在开启事务后,执行大量与数据库无关的耗时操作。
例如:
text
BEGIN
↓
访问远程 HTTP 服务
↓
等待外部接口响应
↓
UPDATE
↓
COMMIT
如果远程接口响应很慢,就会让数据库事务长时间保持开启。
这可能带来锁等待和旧版本保留等问题。
18.2 一次事务应使用同一数据库连接
事务状态属于数据库会话。
如果:
text
BEGIN 使用连接 A
UPDATE 使用连接 B
COMMIT 使用连接 C
那么这些操作不一定属于同一个事务。
因此,使用连接池时必须保证同一事务的相关 SQL 在正确的数据库连接中执行。
18.3 发生异常时必须处理事务状态
如果事务中途出现异常,应用程序应明确回滚或者通过可靠机制结束未提交事务。
不能让带有未结束事务的连接直接回到连接池,被下一个业务请求继续复用。
18.4 不要把 MVCC 当作万能的并发控制机制
MVCC 主要解决不同事务读取历史版本的可见性问题。
对于:
- 库存扣减。
- 账户转账。
- 订单状态流转。
- 唯一性校验。
- 多步骤业务一致性。
仍然需要合理使用事务、锁、条件更新和约束。
十九、常见问题总结
19.1 MVCC 是不是完全无锁?
不是。
普通一致性读可以不对读取的数据行加锁。
但 UPDATE、DELETE、锁定读等操作仍然涉及锁机制。
19.2 Undo Log 是否只保存在内存?
不是。
Undo Log 由 InnoDB 通过相应的数据页和表空间管理,可以被持久化。
19.3 DB_ROW_ID 是否一定存在?
不应该这样理解。
只有在 InnoDB 需要使用内部生成的行 ID 组织聚簇索引时,DB_ROW_ID 才承担相应角色。
19.4 为什么历史版本不会立即删除?
因为其他仍然活跃的事务可能需要读取旧版本。
当历史版本不再被需要时,Purge 等机制可以进一步清理。
19.5 Read View 是完整的数据副本吗?
不是。
Read View 主要保存事务可见性判断所需的信息。
实际记录版本需要结合聚簇索引记录和 Undo 历史信息访问。
19.6 为什么 READ COMMITTED 可能不可重复读?
因为普通一致性读通常每次重新建立 Read View。
后续查询可能看到其他事务新提交的版本。
19.7 为什么 REPEATABLE READ 可以保持快照稳定?
因为普通一致性读通常复用同一个事务中首次一致性读创建的 Read View。
19.8 BEGIN 是否立即创建 Read View?
普通 BEGIN 通常不会立即建立后续一致性读使用的快照。
在 REPEATABLE READ 下,通常第一次一致性读才建立快照。
如果使用:
sql
START TRANSACTION WITH CONSISTENT SNAPSHOT;
则可以在事务开始时建立一致性快照。
19.9 为什么 SELECT FOR UPDATE 能读取新版本?
因为它属于锁定的当前读,不是单纯按照旧 Read View 选择历史版本。
19.10 MVCC 可以解决所有幻读吗?
不能一概而论。
需要区分:
- 普通快照读。
- 当前读。
- 同一事务内的数据修改。
- 锁定范围和隔离级别。
在 InnoDB 的 REPEATABLE READ 下,MVCC 和 Next-Key Lock 等机制能够避免大量典型幻读场景,但不同操作组合仍然需要具体分析。
二十、知识点速查表
| 概念 | 主要作用 |
|---|---|
| MVCC | 多版本并发控制 |
| DB_TRX_ID | 记录最近修改该行版本的事务 ID |
| DB_ROLL_PTR | 关联对应 Undo 信息 |
| DB_ROW_ID | 特定情况下使用的隐藏行 ID |
| Undo Log | 支持回滚和历史版本读取 |
| Redo Log | 支持持久性及崩溃恢复 |
| Read View | 判断数据版本对一致性读是否可见 |
| 快照读 | 根据 Read View 读取可见版本 |
| 当前读 | 基于当前记录状态进行锁定读取或修改 |
| READ COMMITTED | 通常每次一致性读使用新 Read View |
| REPEATABLE READ | 通常在同一事务中复用首次一致性读建立的 Read View |
| Next-Key Lock | 记录锁与间隙锁结合的范围锁定机制 |
| Purge | 清理不再需要的历史记录等 |
二十一、总结
本篇从 InnoDB 的并发控制出发,逐步学习了 MVCC 的内部原理。
首先,我们将事务并发分成三种情况:
text
读---读
读---写
写---写
其中,MVCC 主要为一致性读与写操作的并发执行提供支持。
接下来,学习了 InnoDB 记录中与 MVCC 相关的隐藏字段:
text
DB_TRX_ID
DB_ROLL_PTR
DB_ROW_ID
其中:
- DB_TRX_ID 用于关联产生记录版本的事务。
- DB_ROLL_PTR 用于关联 Undo 回滚信息。
- DB_ROW_ID 在特定情况下参与隐藏聚簇索引的组织。
然后,理解了 Undo Log 和版本链:
text
最新版本
↓
历史版本
↓
更早版本
在此基础上,我们引入 Read View。
Read View 可以结合记录版本对应的事务 ID,判断当前一致性读能否看到该版本。
最后,我们从底层理解了 READ COMMITTED 和 REPEATABLE READ 的重要区别:
READ COMMITTED:
普通一致性读通常每次建立新的 Read View,因此可能读取到其他事务新提交的数据。
REPEATABLE READ:
普通一致性读通常复用同一个 Read View,因此能够在事务中保持稳定的历史可见性。
不过,MVCC 并不能取代锁机制。
当前读、写---写冲突、范围锁和事务执行顺序仍然需要通过其他并发控制机制处理。
理解事务与 MVCC 后,我们就能够从底层解释 MySQL 为什么既可以支持高并发访问,又能够提供不同级别的数据隔离。
文章标签: MySQL 数据库 MVCC Undo Log Read View InnoDB 事务隔离 快照读 当前读 REPEATABLE READ C++后端开发