MySQL 事务隔离级别是如何实现的?从 MVCC 到锁机制原理详解
文章目录
- 事务隔离和MVCC
-
- 一、为什么需要事务并发
- 二、事务并发的三类场景
- 三、并发读写产生的三种读异常
-
- [脏读-Dirty Read](#脏读-Dirty Read)
- [不可重复读-Non-repeatable Read](#不可重复读-Non-repeatable Read)
- [幻读-Phantom Read](#幻读-Phantom Read)
- 三种读异常总结
- 四、事务的隔离性和隔离级别
- 五、实现隔离的底层机制
-
- 1.MVCC
-
- 隐藏字段
- [Undo Log](#Undo Log)
-
- 什么是undo?
- [Undo Log定义](#Undo Log定义)
- [那Undo Log版本链是怎么产生的?](#那Undo Log版本链是怎么产生的?)
- ReadView读视图
- 2.快照读和当前读
- 3.锁机制
-
- 共享锁S和排他锁X
-
- [S共享锁/读锁 Shared Lock](#S共享锁/读锁 Shared Lock)
- [X排他锁/写锁 Exclusive Lock](#X排他锁/写锁 Exclusive Lock)
- 共享锁和排他锁对比总结
- 行锁和表锁
- 记录锁、间隙锁、临键锁
-
- [记录锁 Record Lock](#记录锁 Record Lock)
- [间隙锁 Gap Lock](#间隙锁 Gap Lock)
- [临键锁 Next-Key Lock](#临键锁 Next-Key Lock)
- 记录锁、间隙锁、临键锁对比总结
- 六、底层机制如何配合来实现四种隔离级别
事务隔离和MVCC
一、为什么需要事务并发
什么是事务
事务的定义:
事务transaction
事务是数据库管理系统中的一个逻辑工作单元(一组sql),由一组数据库操作组成
这组操作要么全部成功执行,要么全部不执行,不会停留在中间状态
MySQL有一个系统变量autocommit
| autocommit值 | 行为 |
|---|---|
| 1(默认) | 每条 SQL 自动成为一个事务,执行完自动提交 |
| 0 | 事务不会自动提交,需要手动COMMIT |
两种情况:
1.autocommit=1(默认)
回看autocommit=1时的行为:每条 SQL 自动成为一个事务,执行完自动提交
1)隐式事务
mysql
-- 你输入的
UPDATE t SET v = 200 WHERE id = 1;
通常我们输入这条语句之后,选中语句直接执行了
我们并没有写start transaction(或者用begin)、commit
是因为,autocommit=1,我们在执行这条语句的时候
引擎自动给我们添加了start transaction、commit
mysql
-- 引擎内部实际执行的
START TRANSACTION; ← 自动加的,你看不见
UPDATE t SET v = 200 WHERE id = 1;
COMMIT; ← 自动加的,你看不见
引擎自动给我们添加了start transaction、commit,这种就是隐式事务
2)显式事务
mysql
START TRANSACTION;
UPDATE t SET v = 200 WHERE id = 1;
UPDATE t SET v = 300 WHERE id = 2;
UPDATE t SET v = 400 WHERE id = 3;
COMMIT;
这种我们自己显示写start transaction、commit,叫做显式事务
显式事务和隐式事务的区别
mysql
-- 隐式:每条 SQL 各自一个事务,一共 3 个事务
UPDATE t SET v = 200 WHERE id = 1; -- 事务 1,自动提交
UPDATE t SET v = 300 WHERE id = 2; -- 事务 2,自动提交
UPDATE t SET v = 400 WHERE id = 3; -- 事务 3,自动提交
-- 显式:3 条 SQL 属于同一个事务
START TRANSACTION;
UPDATE t SET v = 200 WHERE id = 1; ┐
UPDATE t SET v = 300 WHERE id = 2; ├ 同一个事务
UPDATE t SET v = 400 WHERE id = 3; ┘
COMMIT;
| 隐式事务 | 显式事务 | |
|---|---|---|
| 事务边界 | 引擎自动划(每条 SQL) | 你手动划(BEGIN 到COMMIT ) |
| 一个事务包含几条 SQL | 1 条 | 任意条 |
中途能否ROLLBACK 撤销前面的 |
不能,每条已经提交了 | 能 |
2.autocommit=0
回看autocommit=0时的行为:事务不会自动提交,需要手动
COMMIT
所以这时候,必须我们手动commit
这就意味着,autocommit=0的时候全部都是显式事务
mysql
START TRANSACTION;// 这个可以省去
UPDATE t SET v = 200 WHERE id = 1; ┐
UPDATE t SET v = 300 WHERE id = 2; ├ 全部属于同一个事务
COMMIT; ┘ 直到你手动提交
多个事务同时要对一个数据库进行操作,怎么办
比如,我们这里有一个表
| id | balance |
|---|---|
| 1 | 1000 |
| 2 | 1000 |
现在有两个事务
事务A:
mysql
START TRANSACTION;
SELECT balance FROM account WHERE id = 1; -- 读当前余额
UPDATE account SET balance = balance - 100
WHERE id = 1; -- 扣款100
UPDATE account SET balance = balance + 100
WHERE id = 2; -- 入账100
COMMIT;
事务B:
mysql
BEGIN;
SELECT balance FROM account WHERE id = 1; -- 读当前余额
UPDATE account SET balance = balance - 50
WHERE id = 1; -- 扣款50
UPDATE account SET balance = balance + 50
WHERE id = 2; -- 入账50
COMMIT;
这两个事务都是对刚才的同一张表进行操作
那这两个事务怎么去执行,是一个事务执行完之后,执行另一个事务嘛(也就是串行执行)?
答案是否定的
为什么不用串行执行
串行执行,效率太慢了
事务需要排队等候,cpu很多时候是限制的,处理效率很低
如果不是串行执行,那还能怎么办?
事务并发执行
一个事务在执行的过程中,穿插着执行别的事务
一个事务在这个执行过程中可能当前暂时不用cpu时,操作系统会切换,让别的事务可以使用cpu执行
这样就充分利用了cpu,尽量让cpu不空闲,这样就能提高多个事务同时到来时的处理效率
二、事务并发的三类场景
事务要做的事情无非就是读和写
那么事务并发就由三种场景
| 场景 | 问题 |
|---|---|
| 并发读读 | 非常安全 |
| 并发写写 | 脏写、可覆盖写 |
| 并发读写 | 脏读、不可重复读、幻读 |
我们今天要讲解的就是:三种读异常是什么、如何解决的
三、并发读写产生的三种读异常
假设有一张用户账户表:
| id | name | balance |
|---|---|---|
| 1 | Tom | 1000 |
| 2 | Jack | 2000 |
脏读-Dirty Read
事务A,事务B
| 时间 | 事务 A | 事务 B |
|---|---|---|
| 1 | BEGIN | |
| 2 | BEGIN | |
| 3 | UPDATE balance = 500 WHERE id = 1 | |
| 4 | SELECT balance FROM account WHERE id = 1 | |
| 5 | ROLLBACK |
执行过程:
- 事务 B 将 Tom 的余额从 1000 修改为 500,但还没有提交
- 事务 A 查询 Tom 的余额,读到了 500
- 事务 B 执行回滚,余额恢复为 1000
这就出现了脏读:事务 A 读取了事务 B 尚未提交的数据,而这份数据最终并没有真正生效
脏读:读取到了其他事务未提交的数据
不可重复读-Non-repeatable Read
| 时间 | 事务 A | 事务 B |
|---|---|---|
| 1 | BEGIN | |
| 2 | SELECT balance FROM account WHERE id = 1 | |
| 3 | BEGIN | |
| 4 | UPDATE account SET balance = 1500 WHERE id = 1 | |
| 5 | COMMIT | |
| 6 | SELECT balance FROM account WHERE id = 1 |
执行过程:
- 事务 A 第一次查询 Tom 的余额,得到 1000
- 事务 B 修改 Tom 的余额为 1500,并提交事务
- 事务 A 再次查询 Tom 的余额,得到 1500
这就出现了不可重复读:同一个事务,两次读取同一条记录,却得到了不同的结果
不可重复读:同一条记录两次读取结果不同
这里不可重复指的是:都是同一条记录的查询,但是读取到的结果是不可重复的->Non-repeatable Read
幻读-Phantom Read
| 时间 | 事务 A | 事务 B |
|---|---|---|
| 1 | BEGIN | |
| 2 | SELECT * FROM account WHERE balance > 1000 | |
| 3 | BEGIN | |
| 4 | INSERT INTO account VALUES (3, 'Lucy', 3000) | |
| 5 | COMMIT | |
| 6 | SELECT * FROM account WHERE balance > 1000 |
执行过程:
- 事务 A 第一次查询余额大于 1000 的用户,查询到 Jack
- 事务 B 插入 Lucy,余额为 3000,并提交事务
- 事务 A 再次执行相同的查询,发现多出了 Lucy
这就出现了幻读:同一个事务,两次执行相同的范围查询,返回的记录集合发生了变化
幻读:相同范围查询,两次结果集合不同
三种读异常总结
| 读异常 | 核心表现 |
|---|---|
| 脏读 | 读取其他事务未提交的数据 |
| 不可重复读 | 同一条记录两次读取结果不同 |
| 幻读 | 相同范围查询,两次结果集合不同 |
四、事务的隔离性和隔离级别
刚才描述的是一个事务插进了另一个事务,从而产生的三种读异常
我们知道,事务是具有隔离性的
那什么是隔离性?
隔离性:
多个事务并发执行时,一个事务的操作不应该受到其他事务中间状态的干扰
多个事务并发执行时,究竟要隔离的什么程度
MySQL提供了四种隔离级别
| 并发问题 | READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE |
|---|---|---|---|---|
| 脏读 | ❌ | ✔️ | ✔️ | ✔️ |
| 不可重复读 | ❌ | ❌ | ✔️ | ✔️ |
| 幻读 | ❌ | ❌ | ✔️ | ✔️ |
隔离级别越高,数据库对事务并发执行的控制通常越严格,相应地也可能带来更大的并发性能开销
在实际生产环境中,需要根据业务对数据一致性的要求、并发访问情况以及性能需求,选择合适的事务隔离级别
下面我们先讲解实现隔离的底层机制,再讲解四种隔离级别具体怎么实现
五、实现隔离的底层机制
InnoDB 实现事务隔离,并不是单纯依靠 MVCC,而是 MVCC 和锁机制相互配合共同完成的
MVCC 解决的是读取哪个版本的问题,锁解决的是并发事务之间哪些操作可以同时进行的问题。
为什么 MySQL 既需要 MVCC,又需要锁?
看这个表:
| 对比 | MVCC | 锁机制 |
|---|---|---|
| 核心作用 | 控制读取哪个版本 | 控制并发访问 |
| 普通 SELECT | 读取可见历史版本 | 通常不加记录锁 |
| FOR UPDATE | 当前读,不按快照选择历史版本 | 申请 X 锁 |
| UPDATE | 不能单靠 MVCC 完成并发控制 | 需要 X 锁 |
不过,最后一行还需要补充:UPDATE 不只是加锁,它还会涉及当前读、数据修改和 Undo Log 版本维护等过程。
1.MVCC
什么是MVCC?
MVCC(Multi-Version Concurrency Control)
通过为数据保留多个版本(undo log实现)
让不同事务能够根据可见性规则读取不同版本的数据(readview实现)
从而减少读写操作之间的冲突
这里我们现有一个大致了解,我们先来介绍隐藏字段、undo log、readview
最后我们再回头看这个MVCC的时候,就醍醐灌顶了
隐藏字段
在 InnoDB 内部,聚簇索引的叶子节点存储着完整的行记录,通常有 三个隐藏字段:
| 隐藏字段 | 含义 |
|---|---|
DB_TRX_ID |
事务 ID,记录最后一次插入或修改该记录的事务 ID(这个事务id是随机分配的,但总体上是自增的) |
DB_ROLL_PTR |
回滚指针,指向 Undo Log 中该记录的上一个版本 |
DB_ROW_ID |
隐藏主键,当表没有定义主键或合适的唯一非空索引时,InnoDB 会生成这个隐藏行 ID |
Undo Log
什么是undo?
如图所示
原始balance=1000,我做了更新操作,变成1500
undo就是,如何把更新操作撤回,变回原来的样子

Undo Log定义
Undo Log 用来记录数据修改前的信息,使数据库能够回滚事务,也能够找到记录的历史版本
那Undo Log版本链是怎么产生的?
现在有下面这三个事务:
mysql
>事务100
插入一条语句:id=1 name=Tom balance=1000
>事务200
更新语句:将id=1这条记录 balance修改为1500
>事务300
更新语句:将id=1这条记录 balance修改为2000
1)事务100
插入一条语句之后,当前行:

由于当前行,就是初次的记录,所以回滚指针指向空
2)事务200
将id=1这条记录 balance修改为1500
会按照以下顺序:
先把原来这条记录,复制到undo log里面,并分配地址

然后修改对这行记录进行修改:把balance改为1500,trx_id改为200,roll_ptr指向刚才的版本

3)事务300
将id=1这条记录 balance修改为2000
先把这条记录复制一份到undo log,分配地址并保持版本链

修改balance=2000,trx_id=300,roll_ptr=0x269588

就像上面这样,就逐渐形成了版本链
这个版本链,就是一个链表,事务回滚的时候,顺着链表就会回滚到对应版本
ReadView读视图
ReadView是什么
当一条记录存在多个历史版本时,InnoDB 怎么判断当前事务应该读取哪个版本?
这就是ReadView要解决的问题
ReadView给出一个可见性规则,来判断出当前事务应该读取那个版本
也就是,对于当前事务来说,哪个版本是可见的
比如,一个事务中执行到select语句的时候,这时候就会创建一个快照,即ReadView
ReadView的核心属性
| 属性 | 含义 |
|---|---|
m_ids |
创建 Read View 时,当前系统中所有活跃的读写事务 ID 集合 |
min_trx_id |
创建 Read View 时,活跃事务 ID 集合中的最小值 |
max_trx_id |
创建 Read View 时,系统将要分配的下一个事务 ID |
creator_trx_id |
创建当前 Read View 的事务 ID |
注意:
活跃的事务是指:该事务已经开始了,但是没有提交
可见性判断规则
当某一个事务执行select语句时
完整过程就是:
- 创建 Read View
- 查询记录的最新版本
- 获取当前版本的
DB_TRX_ID - 根据 Read View 判断当前版本是否可见
- 如果不可见,通过
DB_ROLL_PTR找到上一个历史版本 - 获取历史版本的
DB_TRX_ID,回到第 4 步继续判断 - 找到可见版本,返回数据
| 判断条件 | 可见性 | 原因 |
|---|---|---|
trx_id == creator_trx_id |
可见 | 当前版本由创建 Read View 的事务自身修改 |
trx_id < min_trx_id |
可见 | 修改该版本的事务在 Read View 创建前已经提交 |
trx_id >= max_trx_id |
不可见 | 修改该版本的事务在 Read View 创建之后才获得事务 ID |
min_trx_id <= trx_id < max_trx_id |
需要进一步判断 | 需要检查该事务是否在 m_ids 中:如果在m_ids,该版本不可见,需要再来一次判断;反之,版本可见 |
这个可见性规则秉持的原则是:
只能读取创建 Read View 时已经提交的事务所产生的数据版本,以及当前事务自身的修改
举个例子
我们假设最初有这样一条记录:
设插入这条记录的事务id为1
| id | name | age |
|---|---|---|
| 30 | A0 | 1 |
四个事务按照下面的顺序执行:
下面四个事务设事务id依次为2,3,4,5
| 执行顺序 | 事务2 | 事务3 | 事务4 | 事务5 |
|---|---|---|---|---|
| ① | 开始事务 | |||
| ② | 开始事务 | |||
| ③ | 开始事务 | |||
| ④ | 开始事务 | |||
| ⑤ | 修改 id=30,age=3 | |||
| ⑥ | 查询 id=30 | |||
| ⑦ | 提交事务 | |||
| ⑧ | 修改 id=30,name=A3 | |||
| ⑨ | 查询 id=30 | |||
| ⑩ | 提交事务 | |||
| ⑪ | 修改 id=30,age=10 | |||
| ⑫ | 查询 id=30 | |||
| ⑬ | 再次查询 id=30 | |||
| ⑭ | 提交事务 |
比如,事务5在查询id=30的时候,就会产生一次快照ReadView
下面我们来分析以下,此时事务5查询id=30时,拿到的版本
创建改readview的creator_trx_id=5
1)当前版本链并确定trx_id的值
此时的状态:
事务2已经提交
事务3已经将 name 修改为 A3,但尚未提交
事务4仍然处于活跃状态
很显然,当前版本的trx_id=3

2)列出readview的核心属性
| 属性 | 含义 | 具体放到这个例子中是: |
|---|---|---|
m_ids |
创建 Read View 时,当前系统中所有活跃的读写事务 ID 集合 | 3,4,5 |
min_trx_id |
创建 Read View 时,活跃事务 ID 集合中的最小值 | 3 |
max_trx_id |
创建 Read View 时,系统将要分配的下一个事务 ID | 假设是8 |
creator_trx_id |
创建当前 Read View 的事务 ID | 5 |
3)根据可见性规则找出当前事务可见的版本
trx_id我们在步骤(1)已经找到了,值是3
我们把需要比较的值列出来
| 属性 | 值 |
|---|---|
| trx_id | 3 |
| m_ids | 3,4,5 |
| min_trx_id | 3 |
| max_trx_id | 8 |
| creator_trx_id | 5 |
| 判断条件 | 具体放到这个例子中是: | 当前版本是否可见 |
|---|---|---|
trx_id == creator_trx_id |
3 ?=5 | 不可见 |
trx_id < min_trx_id |
3 ?< 3 | 不可见 |
trx_id >= max_trx_id |
3 ?>= 8 | 不可见 |
min_trx_id <= trx_id < max_trx_id |
3 ?<= 3 ?< 8 | 满足该不等式,但是3∈3,4,5 |
3∈3,4,5,版本不可见
4)当前版本回滚到上一版本,重新判断

当前trx_id=2
| 属性 | 值 |
|---|---|
| trx_id | 2 |
| m_ids | 3,4,5 |
| min_trx_id | 3 |
| max_trx_id | 8 |
| creator_trx_id | 5 |
| 判断条件 | 具体放到这个例子中是: | 当前版本是否可见 |
|---|---|---|
trx_id == creator_trx_id |
2 ?=5 | 不可见 |
trx_id < min_trx_id |
2 ?< 3 | 可见 |
trx_id >= max_trx_id |
2 ?>= 8 | - |
min_trx_id <= trx_id < max_trx_id |
2 ?<= 2 ?< 8 | - |
此时,就找到了事务5可以见到的版本:事务id=2

2.快照读和当前读
快照读
快照读读取的是:当前事务可见的数据版本
依靠 MVCC 机制实现,通过 Read View 判断当前事务能够看到哪个版本
比如,我们执行普通的select就是快照读
根据MVCC,找到该事务可见版本
mysql
SELECT * FROM user WHERE id = 30;
当前读
当前读读取的是:当前行的最新 的可用的版本
并且通常会对读取的记录加锁,以保证后续修改操作的数据一致性
常见的当前读包括:
mysql
SELECT * FROM user WHERE id = 30 FOR UPDATE; # for update
SELECT * FROM user WHERE id = 30 FOR SHARE; # for share
UPDATE user SET age = 20 WHERE id = 30; # update
DELETE FROM user WHERE id = 30; # delete
最新可用版本:不是简单地指最新写入的版本,而是指经过并发事务控制后,当前读能够读取的最新版本
举个例子
假设 id=30 的记录原本是:
| age | 状态 |
|---|---|
| 10 | 已提交 |
现在:
- 事务 A 将
age修改为 20,但尚未提交 - 事务 B 执行
SELECT ... FOR UPDATE
此时,事务 B 不能直接读取事务 A 尚未提交的 age=20
它需要等待事务 A 结束(提交或回滚),然后再读取符合当前读规则的版本
- 如果事务 A 提交,事务 B 读取
age=20 - 如果事务 A 回滚,事务 B 读取
age=10
这就是"最新可用的版本"
3.锁机制
锁的分类
- 按照锁的兼容性:共享锁、排他锁
- 按照锁的粒度:表锁、行锁
- 按照锁定的范围:记录锁、间隙锁、临键锁
共享锁S和排他锁X
S共享锁/读锁 Shared Lock
核心特点:多个事务可以同时持有同一条记录的共享锁
多个事务可以同时读同一条记录

X排他锁/写锁 Exclusive Lock
核心特点:一个事务持有某条记录的排他锁时,其他事务不能再获得这条记录的 S 锁或 X 锁
如果该记录上面有X锁,那么其他事务需要等待该记录上面的X锁释放之后,才能读写

共享锁和排他锁对比总结
这里的等待指的是:等待已有冲突锁释放
| 当前记录持有的锁 | 其他事务请求 S 锁 | 其他事务请求 X 锁 |
|---|---|---|
| 共享锁(S) | 允许 | 等待 |
| 排他锁(X) | 等待 | 等待 |
行锁和表锁
| 行锁(Row Lock) | 表锁(Table Lock) |
|---|---|
| 锁定范围是一条或多条索引记录 | 锁定范围是整张表 |
为什么行锁可能锁定多条记录?
如果有 5 条记录满足条件,那么 InnoDB 可能需要锁定多条索引记录
记录锁、间隙锁、临键锁
这三种锁都属于行锁
记录锁 Record Lock
对索引记录加锁
将锁的范围控制在具体的索引记录上,而不必直接锁住整张表
我们可以说对某一条记录加锁嘛?
可以
- 业务角度: 对 user 表中 id=2 这一行加锁
- 数据库操作角度: 对 id=2 这条记录加锁
- InnoDB 实现角度: 对聚簇索引中 id=2 对应的索引记录加锁
我们为什么要强调索引记录?
InnoDB 可能涉及二级索引记录和聚簇索引记录上的锁
InnoDB 通过索引找到数据,而一行数据可能同时存在于多棵索引树中
注意:InnoDB 不仅要保护最终的数据行,还要保护访问这些数据所依赖的索引记录及其范围,因为索引本身也参与并发访问和数据维护
间隙锁 Gap Lock
间隙锁就是锁定索引记录之间的一个范围,阻止其他事务在这个范围内插入新记录
临键锁 Next-Key Lock
我们已经认识了两种锁:
- 记录锁(Record Lock):锁住已经存在的索引记录。
- 间隙锁(Gap Lock):锁住索引记录之间的间隙。
那么问题来了:
如果我既想锁住一条记录,又想锁住它前面的间隙,应该怎么办?
InnoDB 就有一种锁:临键锁(Next-Key Lock)
临键锁由记录锁和间隙锁组合而成
Next-Key Lock = Record Lock + Gap Lock \text{Next-Key Lock}=\text{Record Lock}+\text{Gap Lock} Next-Key Lock=Record Lock+Gap Lock
举个例子:
假设主键索引有以下数据:
| id |
|---|
| 1 |
| 5 |
| 10 |
| 15 |
有以下临键锁:
| 临键锁 | 说明 |
|---|---|
| (-∞, 1] | id=1 前面的间隙锁和 id=1本身记录锁 |
| (1, 5] | (1, 5)的间隙锁和 id=5本身记录锁 |
| (5, 10] | (5, 10)的间隙锁和 id=10本身记录锁 |
| (10, 15] | (10, 15)的间隙锁和 id=15本身记录锁 |
记录锁、间隙锁、临键锁对比总结
| 锁类型 | 锁定范围 | 主要作用 |
|---|---|---|
| 记录锁 | 单条索引记录 | 防止其他事务修改该记录 |
| 间隙锁 | 两条索引记录之间的间隙 | 防止其他事务在间隙中插入记录 |
| 临键锁 | 间隙 + 后面的索引记录 | 同时保护记录和间隙 |
六、底层机制如何配合来实现四种隔离级别
| 并发问题 | READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE |
|---|---|---|---|---|
| 脏读 | ❌ | ✔️ | ✔️ | ✔️ |
| 不可重复读 | ❌ | ❌ | ✔️ | ✔️ |
| 幻读 | ❌ | ❌ | ✔️ | ✔️ |
RU-read uncommitted读未提交
读未提交
允许事务读取其他事务没有提交的数据
| MVCC机制 | READ UNCOMMITTED 的表现 |
|---|---|
| Read View | 普通读不使用 Read View 可见性规则 |
| Undo Log | 仍然存在,用于事务回滚等 |
| 操作 | 操作特点 | 是否使用锁 | 作用 |
|---|---|---|---|
| 普通 SELECT | 非锁定读 | 通常不加记录 S/X 锁 | 允许读取其他事务尚未提交的数据 |
| UPDATE | 当前读 | 使用 X 锁 | 防止多个事务同时修改冲突记录 |
| DELETE | 当前读 | 使用 X 锁 | 防止多个事务同时删除或修改冲突记录 |
| SELECT ... FOR UPDATE | 锁定读 | 使用 X 锁 | 锁定读取的记录 |
| SELECT ... FOR SHARE | 锁定读 | 使用 S 锁 | 保护读取的记录,协调并发修改 |
1.脏读
举个例子
假设初始余额为 1000
事务 A:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
-- 尚未提交
事务 B:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 读到 2000
事务 A:
mysql
ROLLBACK;
此时 B 读到的 2000 实际上已经被回滚了
在这种隔离级别下,为什么会产生脏读?
MVCC 方面:
RU 的普通 SELECT 不使用 Read View 的可见性规则筛选版本,因此不会因为 A 尚未提交,就回溯到之前已提交的 1000 版本
锁机制方面:
B 的普通 SELECT 通常不申请记录 S 锁,因此不会与 A 持有的 X 锁发生冲突,不需要等待 A 提交
2.不可重复读
初始余额为 1000
事务 A:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 1000
事务 B:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
COMMIT;
事务 A 再次执行:
mysql
SELECT balance FROM user WHERE id = 1;
-- 2000
在这种隔离级别下,为什么会产生不可重复读?
MVCC 方面:
RU 不通过 Read View 固定普通 SELECT 的版本可见性,因此 A 第二次查询可以读到 B 提交后的新版本
锁机制方面:
A 的第一次普通 SELECT 没有申请记录 S 锁,所以没有阻止 B 对这条记录进行 UPDATE
于是A 再次读取的时候,就可能读取到刚更新的数据,从而产生不可重复读
3.幻读
假设表中有以下数据:
| id | age |
|---|---|
| 1 | 18 |
| 2 | 20 |
| 3 | 25 |
事务 A:
mysql
BEGIN;
SELECT * FROM user WHERE age >= 20 AND age <= 30;
查询结果:id=2、id=3
事务 B
mysql
BEGIN;
INSERT INTO user (id, age) VALUES (4, 23);
COMMIT;
事务 A 再次执行:
mysql
SELECT * FROM user WHERE age >= 20 AND age <= 30;
查询结果多出了 id=4
在这种隔离级别下,为什么会产生幻读?
MVCC 方面:
RU 不使用 Read View 固定两次查询的版本可见性,因此第二次查询可以看到 B 提交的新记录
锁机制方面:
A 的普通范围 SELECT 通常没有使用 Gap Lock 或 Next-Key Lock 保护查询范围,因此没有阻止 B 在这个范围内插入新记录
RU总结
| 并发问题 | READ UNCOMMITTED |
|---|---|
| 脏读 | ❌ |
| 不可重复读 | ❌ |
| 幻读 | ❌ |
RC-read committed读已提交
读已提交
一个事务只能读取其他事务已经提交的数据,不能读取其他事务尚未提交的修改
RC 最核心的特点:
普通 SELECT 每次执行时,都会创建一个新的 Read View,因此每次查询都能读取当时已经提交的数据
| MVCC 机制 | READ COMMITTED 的表现 |
|---|---|
| Read View | 每次普通一致性读都会创建新的 Read View |
| Undo Log | 保存数据历史版本,供 MVCC 沿版本链查找可见版本 |
| 版本可见性 | 只能读取 Read View 允许访问的已提交版本 |
| 操作 | 操作特点 | 是否使用锁 | 作用 |
|---|---|---|---|
| 普通 SELECT | 快照读(非锁定一致性读) | 通常不加记录 S/X 锁 | 通过 Read View 读取已提交版本 |
| UPDATE | 修改当前记录 | 使用 X 锁 | 防止多个事务同时修改冲突记录 |
| DELETE | 删除当前记录 | 使用 X 锁 | 协调并发删除和修改 |
| SELECT ... FOR UPDATE | 当前读 | 使用 X 锁 | 锁定读取的记录 |
| SELECT ... FOR SHARE | 当前读 | 使用 S 锁 | 保护读取的记录,协调并发修改 |
1.脏读
在RC这种隔离级别下,事务只能读取已经提交的数据
但是RC 和 RU 一样,普通 SELECT 通常都不申请记录 S/X 锁
那么问题来了:
既然 RC 没有通过记录 S 锁阻止其他事务修改数据,它是怎么避免脏读的?
答案是:MVCC
举个例子,假设初始余额为 1000
事务 A:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
-- 尚未提交
事务 B:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 读到 1000
为什么 RC 能够避免脏读?
MVCC 方面:
RC 每次普通一致性读都会创建新的 Read View,通过 Read View 的可见性规则判断数据版本是否可见
由于事务 A 尚未提交,因此 A 修改产生的 2000 对 B 不可见,B 会通过 Undo Log 找到已提交的 1000
锁机制方面:
RC 和 RU 一样,普通 SELECT 通常都不申请记录 S/X 锁
因此不会与 A 持有的 X 锁发生冲突,也不需要等待 A 提交,直接通过MVCC找到可读的历史版本,不会读取到A还没有提交的修改
所以避免脏读,锁机制在这方面没有功劳
2.不可重复读
假设初始余额为 1000
事务 A:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 1000
事务 B:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
COMMIT;
事务 A 再次执行:
mysql
SELECT balance FROM user WHERE id = 1;
-- 2000
为什么 RC 无法避免不可重复读?
MVCC 方面:
RC 每次普通 SELECT 都会创建新的 Read View,根据可见性规则判断能够读取到哪个版本
- 第一次查询时,B 尚未修改数据,A 读取到 1000
- 第二次查询时,B 已经提交,A 创建新的 Read View
- 新的 Read View 可以看到 B 提交的 2000
因此,同一个事务两次读取同一条记录,可能得到不同的结果
锁机制方面:
和RU一样,A 的第一次普通 SELECT 没有申请记录 S 锁,因此没有阻止 B 对这条记录执行 UPDATE
B 修改时申请 X 锁,提交后释放锁
A 再次普通 SELECT 不需要等待 B 释放锁,可以读取已经提交的 2000
3.幻读
假设表中有以下数据:
| id | age |
|---|---|
| 1 | 18 |
| 2 | 20 |
| 3 | 25 |
事务 A:
mysql
BEGIN;
SELECT * FROM user WHERE age >= 20 AND age <= 30;
查询结果:id=2、id=3
事务 B:
mysql
BEGIN;
INSERT INTO user (id, age) VALUES (4, 23);
COMMIT;
事务 A 再次执行:
mysql
SELECT * FROM user WHERE age >= 20 AND age <= 30;
查询结果多出了 id=4
为什么 RC 无法避免幻读?
MVCC 方面:
RC 每次普通 SELECT 都会创建新的 Read View
- 第一次查询时,B 尚未插入数据
- 第二次查询时,B 已经提交
- 新的 Read View 可以看到 B 插入的新记录
锁机制方面:
A 的普通范围 SELECT 通常没有使用 Gap Lock 或 Next-Key Lock 保护查询范围,因此没有阻止 B 在这个范围内插入新记录
RC总结
| 并发问题 | READ COMMITTED | 核心原因 |
|---|---|---|
| 脏读 | ✔️ | Read View 排除了其他事务未提交的版本 |
| 不可重复读 | ❌ | 每次普通 SELECT 创建新的 Read View |
| 幻读 | ❌ | 新 Read View 能看到新提交的记录,普通范围查询通常没有范围锁保护 |
RR-repeatable read可重复读
可重复读
在同一个事务中,多次执行普通一致性读,能够读取到同一个 Read View 下可见的数据版本
| MVCC 机制 | REPEATABLE READ 的表现 |
|---|---|
| Read View | 同一个事务通常在第一次普通一致性读时创建 Read View,后续普通一致性读复用它 |
| Undo Log | 保存数据历史版本,供 MVCC 沿版本链查找可见版本 |
| 版本可见性 | 同一个事务的普通一致性读通常按照同一个 Read View 判断版本是否可见 |
| 操作 | 操作特点 | 是否使用锁 | 作用 |
|---|---|---|---|
| 普通 SELECT | 快照读 | 通常不加记录 S/X 锁 | 通过同一个 Read View 读取一致的历史版本 |
| UPDATE | 修改当前记录 | 使用 X 锁 | 防止多个事务同时修改冲突记录 |
| DELETE | 删除当前记录 | 使用 X 锁 | 协调并发删除和修改 |
| SELECT ... FOR UPDATE | 当前读 | 使用 X 锁 | 锁定读取的记录 |
| SELECT ... FOR SHARE | 当前读 | 使用 S 锁 | 保护读取的记录,协调并发修改 |
RR 与 RC 在锁机制上的一个重要区别
RR 下,锁定读和修改操作在需要保护索引范围时,可以使用:
- Record Lock:记录锁,保护具体索引记录
- Gap Lock:间隙锁,保护索引记录之间的间隙,阻止其他事务向间隙插入记录
- Next-Key Lock:临键锁,Record Lock + Gap Lock
这些锁可以帮助 RR 防止当前读场景下的幻读
实际加锁范围取决于索引、执行计划、查询条件和访问路径,并不是所有 SQL 都会加 Next-Key Lock
1.脏读
和RC一样,普通 SELECT 通过 Read View 判断数据版本是否可见
所以RR能够避免脏读
2.不可重复读
假设初始余额为 1000。
事务 A:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 1000
事务 B:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
COMMIT;
事务 A 再次执行:
mysql
SELECT balance FROM user WHERE id = 1;
-- 仍然是 1000
为什么 RR 能够避免不可重复读?
MVCC 方面:
RR 在同一个事务中复用第一次普通一致性读创建的 Read View
- 第一次查询,读取 1000
- B 修改余额为 2000 并提交
- 第二次查询,A 仍然复用原来的 Read View
- B 的新版本对 A 不可见,因此 A 仍然读取 1000
锁机制方面:
A 的普通 SELECT 通常没有申请记录 S 锁,因此没有阻止 B 执行 UPDATE
但是,A 仍然可以通过 MVCC 读取历史版本
注意:如果 A 第二次执行的是 SELECT ... FOR UPDATE,情况就不同了。它属于当前读,会读取当前可读取的最新版本,而不是继续读取原来的快照版本
所以: Read View 复用保证普通快照读的可重复性,但不保证快照读和当前读混合使用时,读取结果始终相同
3.幻读
先看一个例子。
假设表中有以下数据:
| id | age |
|---|---|
| 1 | 18 |
| 2 | 20 |
| 3 | 25 |
事务 A:
mysql
BEGIN;
SELECT * FROM user
WHERE age >= 20 AND age <= 30
FOR UPDATE; # 当前读
假设查询通过 age 二级索引进行范围扫描,InnoDB 根据访问范围加上相应的 Next-Key Lock
事务 B:
mysql
BEGIN;
INSERT INTO user (id, age) VALUES (4, 23);
此时,B 的插入可能被阻塞
为什么 RR 能够防止当前读场景下的幻读?
MVCC 方面:
对于普通快照读,RR 复用同一个 Read View
因此,即使其他事务插入并提交了符合条件的新记录,当前事务的普通 SELECT 仍然可能看不到这条新记录
锁机制方面:
对于当前读,RR 可以使用 Next-Key Lock 保护索引记录及其前面的间隙
因此,其他事务不能随意向受保护的范围插入新记录
这里要区分:
- 普通快照读:主要依靠 MVCC 的 Read View 避免幻读
- 当前读:主要依靠 Next-Key Lock 等锁机制防止幻读
这也是 RR 与 RC 在锁机制上的一个重要区别
| 并发问题 | REPEATABLE READ | 核心原因 |
|---|---|---|
| 脏读 | ✔️ | Read View 排除其他事务未提交的版本 |
| 不可重复读 | 普通快照读✔️ | 同一事务复用 Read View |
| 幻读 | ✔️ | 快照读依靠 MVCC;当前读依靠 Next-Key Lock 等范围锁 |
Serializable可串行化
可串行化
可串行化并不是说数据库真的只能同时运行一个事务,而是通过锁机制控制并发事务之间的冲突,使最终结果等价于某种串行执行顺序
普通读取也参与锁竞争,进一步限制事务之间的并发读写
例如,事务 A 和事务 B 同时执行:
- A 读取一条记录。
- B 想要修改这条记录。
- 在 SERIALIZABLE 下,如果 A 持有该记录的 S 锁,B 就不能直接修改,必须等待 A 释放锁。
这就是它的核心思路:通过锁机制控制并发事务的执行
| MVCC | SERIALIZABLE 下的情况 |
|---|---|
| Read View | 显式事务中,普通 SELECT 会转换为共享锁定读,不再依靠普通快照读的 Read View 来决定读取版本 |
| Undo Log | 仍然存在,负责保存历史版本、支持事务回滚等 |
| 版本可见性 | 显式事务中的普通 SELECT 主要通过锁机制协调并发访问 |
| 操作 | 读取/修改方式 | 锁机制 |
|---|---|---|
| 普通 SELECT(显式事务) | 共享锁定读 | S 锁 |
| UPDATE | 修改记录 | X 锁 |
| DELETE | 删除记录 | X 锁 |
| SELECT ... FOR UPDATE | 当前读 | X 锁 |
| SELECT ... FOR SHARE | 当前读 | S 锁 |
1.脏读
事务 A:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
-- 暂不提交
事务 B:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
事务 A 修改记录时持有 X 锁
事务 B 的普通 SELECT 在显式事务下会转换为共享锁定读,需要获取 S 锁
但是 S 锁和 A 的 X 锁冲突,因此 B 必须等待
A 提交后,B 才能继续读取
所以,事务B不会读取到A还没有提交的修改,所以能够避免脏读
原因分析:
- MVCC:这里主要不是依靠 Read View 排除未提交版本
- Lock:B 需要获取 S 锁,与 A 持有的 X 锁冲突,因此等待 A 提交
2.不可重复读
事务 A:
mysql
BEGIN;
SELECT balance FROM user WHERE id = 1;
-- 1000
事务 B:
mysql
BEGIN;
UPDATE user SET balance = 2000 WHERE id = 1;
事务 B 需要获取 X 锁
但 A 已经对读取的记录持有 S 锁,因此 B 必须等待
A 再次查询时:
mysql
SELECT balance FROM user WHERE id = 1;
-- 1000
由于 A 的 S 锁仍然持有,B 无法完成修改并提交
原因分析:
- MVCC:这里不是依靠复用 Read View 保证重复读取结果
- Lock:A 持有 S 锁,阻止 B 获取 X 锁修改记录,直到 A 结束事务
3.幻读
事务 A:
mysql
BEGIN;
SELECT * FROM user
WHERE age BETWEEN 20 AND 30;
假设查询结果有两条记录
事务 B:
mysql
BEGIN;
INSERT INTO user (id, age)
VALUES (4, 23);
A 通过 age 索引进行范围扫描,并且相关范围受到 Next-Key Lock 保护,那么 B 插入 age = 23 的记录时就会受到阻塞
A 提交后,B 才能继续插入
原因分析:
- MVCC:这里不是依靠普通快照读的 Read View 保证范围不变
- Lock:Next-Key Lock 等范围锁保护索引记录及间隙,阻止其他事务在受保护范围内插入新记录
| 并发问题 | SERIALIZABLE |
|---|---|
| 脏读 | ✔️ |
| 不可重复读 | ✔️ |
| 幻读 | ✔️ |
四种隔离级别总结
- RU: 普通读不按 Read View 过滤未提交版本,允许读取未提交数据
- RC: 每次普通快照读创建新的 Read View,只读取已提交版本
- RR: 同一事务复用 Read View,保证普通快照读的可重复性;当前读通过锁机制保护记录和范围
- Serializable: 显式事务中的普通 SELECT 也采用共享锁定读,通过更严格的锁机制协调并发事务
MVCC和锁机制总结
1.MVCC :普通一致性读应该读取哪个版本
2.锁机制:协调事务之间的冲突访问
第一,防止多个事务同时冲突地操作同一条记录
| 锁 | 作用 | 兼容关系 |
|---|---|---|
| S 锁 | 允许读取,阻止其他事务获取 X 锁 | S 与 S 兼容 |
| X 锁 | 独占访问,阻止其他事务获取 S/X 锁 | 与 S/X 均不兼容 |
第二,保护索引范围,防止其他事务在范围内插入新记录
| 锁 | 作用 |
|---|---|
| Record Lock | 锁定具体索引记录 |
| Gap Lock | 锁定索引记录之间的间隙 |
| Next-Key Lock | Record Lock + Gap Lock |
完结撒花~
