MySQL 事务隔离级别是如何实现的?从 MVCC 到锁机制原理详解

MySQL 事务隔离级别是如何实现的?从 MVCC 到锁机制原理详解

文章目录

事务隔离和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

执行过程:

  1. 事务 B 将 Tom 的余额从 1000 修改为 500,但还没有提交
  2. 事务 A 查询 Tom 的余额,读到了 500
  3. 事务 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

执行过程:

  1. 事务 A 第一次查询 Tom 的余额,得到 1000
  2. 事务 B 修改 Tom 的余额为 1500,并提交事务
  3. 事务 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

执行过程:

  1. 事务 A 第一次查询余额大于 1000 的用户,查询到 Jack
  2. 事务 B 插入 Lucy,余额为 3000,并提交事务
  3. 事务 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语句时

完整过程就是:

  1. 创建 Read View
  2. 查询记录的最新版本
  3. 获取当前版本的 DB_TRX_ID
  4. 根据 Read View 判断当前版本是否可见
  5. 如果不可见,通过 DB_ROLL_PTR 找到上一个历史版本
  6. 获取历史版本的 DB_TRX_ID,回到第 4 步继续判断
  7. 找到可见版本,返回数据
判断条件 可见性 原因
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 已提交

现在:

  1. 事务 A 将 age 修改为 20,但尚未提交
  2. 事务 B 执行 SELECT ... FOR UPDATE

此时,事务 B 不能直接读取事务 A 尚未提交的 age=20

它需要等待事务 A 结束(提交或回滚),然后再读取符合当前读规则的版本

  • 如果事务 A 提交,事务 B 读取 age=20
  • 如果事务 A 回滚,事务 B 读取 age=10

这就是"最新可用的版本"

3.锁机制

锁的分类

  1. 按照锁的兼容性:共享锁、排他锁
  2. 按照锁的粒度:表锁、行锁
  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

对索引记录加锁

将锁的范围控制在具体的索引记录上,而不必直接锁住整张表

我们可以说对某一条记录加锁嘛?

可以

  1. 业务角度: 对 user 表中 id=2 这一行加锁
  2. 数据库操作角度: 对 id=2 这条记录加锁
  3. 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
脏读 ✔️
不可重复读 ✔️
幻读 ✔️

四种隔离级别总结

  1. RU: 普通读不按 Read View 过滤未提交版本,允许读取未提交数据
  2. RC: 每次普通快照读创建新的 Read View,只读取已提交版本
  3. RR: 同一事务复用 Read View,保证普通快照读的可重复性;当前读通过锁机制保护记录和范围
  4. 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

完结撒花~

相关推荐
Decay__9 小时前
PostgreSQL 数据库全栈运维实战系列 — 合集索引(24 篇)
运维·数据库·sql·mysql·架构
武昌库里写JAVA9 小时前
SpringBoot+Vue 项目介绍
java·javascript·git·sql·ai
田超凡10 小时前
深入理解MySQL_经典问题总结2
mysql·java-ee
FungLeo12 小时前
FengCMS · PHP+MySQL 升级实录 · 危险默认值之殇:root/123456、认证码 8888 写进配置加载器
android·mysql·php·安全加固·fengcms
琳少_13 小时前
java程序开发笔记
java·开发语言·数据库·笔记
ZhengEnCi14 小时前
覆盖索引怎么设计:从回表代价到 MySQL 与 PostgreSQL 的落地写法
sql·mysql·postgresql
FungLeo15 小时前
FengCMS · PHP+MySQL升级实录 ·并发一致性连环坑:模板缓存、排队保存、备份恢复的竞态
mysql·缓存·php·工程实践·fengcms
Z21-X17 小时前
云原生运维学习笔记:Kubernetes Volume 与 Secret 实验
运维·笔记·学习·云原生·kubernetes
一只大鸽子17 小时前
游戏开发笔记7-Godot RPG游戏基础-场景切换、全局脚本
笔记·游戏·godot