# mysql 事务中的MVCC

# 1. MVCC 的基本介绍以及当前读、快照读

全称 Multi-Version Concurrency Control,多版本并发控制。
指维护一个数据的多个版本,使得读写操作没有冲突,快照读为MySQL实现MVCC提供了一个非阻塞读功能。MVCC的具体实现,还需要依赖于数据库记录中的三个隐式字段、undo log日志和readView。
1
2
# 1.1 当前读
/*
当前读读取的是记录的最新版本,读取时还要保证其他并发事务不能修改当前记录,会对读取的记录进行加锁。

对于我们日常的操作,如:select … lock in share mode(共享锁),select …for update、update、insert、delete(排他锁)都是一种当前读。
*/
1
2
3
4
5
  • 演示案例 session1
-- 开启一个事物
mysql> begin ;
Query OK, 0 rows affected (0.00 sec)

-- 查询当前数据
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | PHP    |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 更新当前数据
mysql> update course set name='JS' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 当前会话更新成功
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | JS     |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 提交事务
mysql> commit;
Query OK, 0 rows affected (0.00 sec)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

session2

-- 会话2开启一个事物
mysql> begin ;

-- 会话1操作之前普通查询,session1事务就算提交了,当前会话也不会读到更新的数据,因为当前的隔离级别是可重复读。
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | PHP    |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 会话1提交事务之后使用lock in share mode 进行当前读,发现已经更改
mysql> select * from course lock in share mode;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | JS     |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

/*
    MySQL默认的事务隔离级别是Repeatable Read,在同一次事务中,多次读取到的数据应该是一致的才对。
其实这就是因为我们当前读取数据的方式是当前读,即使是在默认的RR隔离级别下,使用当前读依然能够读取到其他事务最新提交的数据
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 1.2 快照读
/*
简单的select(不加锁)就是快照读,快照读,读取的是记录数据的可见版本,有可能是历史数据,快照读是不加锁的,是非阻塞读。
    A) 当我们的事务隔离级别是Read Committed时,每次select,都生成一个快照读。

    B) 当我们的事务隔离级别是Repeatable Read时:开启事务后第一个select语句才是快照读的地方。

    C) 当我们的事务隔离级别是Serializable时:快照读会退化为当前读。

*/
1
2
3
4
5
6
7
8
9
  • 演示案例

session1

-- 当前会话开启事务
mysql> begin ;
Query OK, 0 rows affected (0.00 sec)

-- 更新之前查询
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | PHP    |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 进行数据更新
mysql> update course set name='C#' where id = 2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 更新成功
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | JS     |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 提交事务
mysql> commit;
Query OK, 0 rows affected (0.00 sec)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

session2

-- 会话2 开启事务
mysql> begin ;

-- 查询
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | JS    |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

-- 快照读查询,数据依旧没有更改
mysql> select * from course;
+----+--------+
| id | name   |
+----+--------+
|  1 | C++    |
|  2 | JS     |
|  3 | MySQL  |
|  4 | Golang |
| 15 | Python |
+----+--------+
5 rows in set (0.00 sec)

/*
因为在Repeatable Read隔离级别下,开启事务后第一个select语句是快照读的地方,
也就是说,在Repeatable Read隔离级别下,无论我们执行多少次查询操作,查询的结果都与第一次查询时的数据保持一致
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 2. MVCC 的实现基础

/*
MVCC(Multi-Version Concurrency Control ,多版本并发控制)指的就是在使用read-committed、repeatable-read这两种隔离级别的事务,在执行普通的 SELECT 操作时,访问记录的版本链的过程.
    1) 这样子可以使不同事务的读-写、写-读操作并发执行,从而提升系统性能。
    2) read-committed、repeatable-read 这两个隔离级别的一个很大不同就是:生成ReadView 的时机不同
    3) read-committed 在每一次进行普通 select 操作前都会生成一个 ReadView,而repeatable-read 只在第一次进行普通 select 操作前生成一个 ReadView,之后的查询操作都重复使用这个 ReadView 就好了

MVCC最大的优势:读不加锁,读写不冲突。在读多写少的OLTP应用中,读写不冲突是非常重要的,极大的增加了系统的并发性能

事务的隔离级别:读未提交(READ UNCOMMITED)->读已提交(READ COMMITTED)->可重复读(REPEATABLE READ)->序列化(SERIALIZABLE)。隔离级别依次增强,但是导致的问题是并发能力的减弱。

*/
1
2
3
4
5
6
7
8
9
10
11
隔离级别 脏读 不可重复读 幻读 概念
READ UNCOMMITED √ √ √ 事务能够看到其他事务没有提交的修改,当另一个事务又回滚了修改后的情况,又被称为脏读dirty read
READ COMMITTED × √ √ 事务能够看到其他事务提交后的修改,这时会出现一个事务内两次读取数据可能因为其他事务提交的修改导致不一致的情况,称为不可重复读
REPEATABLE READ × × √ 事务在两次读取时读取到的数据的状态是一致的
SERIALIZABLE × × × 可重复读中可能出现第二次读读到第一次没有读到的数据,也就是被其他事务插入的数据,这种情况称为幻读phantom read, 该级别中不能出现幻读
/*
大多数数据库系统的默认隔离级别都是READ COMMITTED(但MySQL不是),InnoDB存储引擎默认隔离级别REPEATABLE READ,
通过多版本并发控制(MVCC,Multiversion Concurrency Control)解决了幻读的问题

MVCC 的实现流程流程如下:
*/
1
2
3
4
5
6

image

# 2.1 事务日志
/*
MySQL Innodb中跟数据持久性、一致性有关的日志,有以下几种:

    Bin Log:是mysql服务层产生的日志,常用来进行数据恢复、数据库复制,常见的mysql主从架构,就是采用slave同步master的binlog实现的

    Redo Log:记录了数据操作在物理层面的修改,mysql中使用了大量缓存,修改操作时会直接修改内存,而不是立刻修改磁盘,事务进行中时会不断的产生redo log,
    在事务提交时进行一次flush操作,保存到磁盘中。当数据库或主机失效重启时,会根据redo log进行数据的恢复,如果redo log中有事务提交,则进行事务提交修改数据。
    
    Undo Log: 除了记录redo log外,当进行数据修改时还会记录undo log,undo log用于数据的撤回操作,它记录了修改的反向操作,
    比如,插入对应删除,修改对应修改为原来的数据,通过undo log可以实现事务回滚,并且可以根据undo log回溯到某个特定的版本的数据,实现MVCC

*/
1
2
3
4
5
6
7
8
9
10
11
12
# 2.2 隐藏字段
/*
1) 我们在查看表结构的时候,就可以显式的看到这看到我们创建的字段。
实际上除了这三个字段以外,InnoDB还会自动的给我们添加三个隐藏字段。

2) 其中的前两个字段是是一定会被添加的, 而最后一个字段DB_ROW_ID添加与否需要根据当前表是否存在主键,如果存在主键,则不会添加该字段。

3) MySQL的每行记录逻辑上其实是一个链表。

4) 每次更新后,都会将旧值放到一条 undo log 中,就算是该记录的一个旧版本,随着更新次数的增多,所有的版本都会被roll_ptr 属性连接成一个链表,我们把这个链表称之为版本链,版本链的头节点就是当前记录最新的值。另外,每个版本中还包含生成该版本时对应的 事务id(trx_id)。
*/
1
2
3
4
5
6
7
8
9
10
隐藏字段 含义
db_trx_id 最近修改事务ID,记录插入这条记录或最后一次,修改该记录的事务ID
db_roll_ptr 回滚指针,指向这条记录的上一个版本,用于配合undo log,指向上一个版本
db_row_id 隐藏主键,如果表结构没有指定主键,将会生成该隐藏字段
# 2.3 undolog

undo log 版本链形成过程 image

/*
最终,不同事务或相同事务对同一条记录进行修改,会导致该记录的undolog生成一条记录版本链表,链表的头部是最新的旧记录,链表尾部是最早的旧记录

1) 执行事务2的时候undo log会记录原有的数据记录,也就是上图undo log中0x00001的undo log,当事务发生回滚的时候就依据这一天undo log进行回滚

2) 执行事务2的时候它的上一次事务记录是0x00001,所以它的db_rool_ptr会记录0x00001的地址,同时数据记录中的db_roll_ptr会指向最后一次事务操作的的id,也就是0x00002,这样就行程了一个版本链
*/
1
2
3
4
5
6
7

image

/*
3) 多个事务执行多次事务之后就会形成这样一条版本链,从而在发生事务回滚的时候以及进行快照读的时候进行使用
*/
1
2
3

不同操作产生undo log的生命周期

/*
1) undolog是回滚日志,在insert、update、delete的时候产生的便于数据回滚的日志。

2) 当insert的时候,产生的undo log日志只在回滚时需要,在事务提交后,可被立即删除。 

3) 而update、delete的时候,产生的undo log日志不仅在回滚时需要,在快照读时也需要,不会立即被删除。
*/
1
2
3
4
5
6
7
# 2.4 readview
/*
1) ReadView(读视图)是 快照读 SQL执行时MVCC提取数据的依据,ReadView中记录并维护系统当前活跃的事务(未提交的)id
2) ReadView中包含了四个核心字段: m_ids, min_trx_id, max_trx_id, creator_trx_id
*/
1
2
3
4
字段 含义
m_ids 当前活跃的事务ID集合
min_trx_id 最小活跃事务ID
max_trx_id 预分配事务ID,当前最大事务ID+1(因为事务ID是自增的)
creator_trx_id ReadView创建者的事务ID
/*
3) ReadView中还规定了版本链数据的访问规则(trx_id 代表当前undolog版本链对应事务ID)
*/
1
2
3
条件 是否可以访问 说明
trx_id == creator_trx_id 可以访问该版本 成立,说明数据是当前这个事务更改的
trx_id < min_trx_id 可以访问该版本 成立,说明数据已经提交了
trx_id > max_trx_id 不可以访问该版本 成立,说明该事务是在ReadView生成后才开启
min_trx_id <= trx_id<= max_trx_id 如果trx_id不在m_ids中,是可以访问该版本的 成立,说明数据已经提交
/*
4) 不同的隔离级别,生成ReadView的时机不同
    READ COMMITTED :在事务中每一次执行快照读时生成ReadView。

    REPEATABLE READ:仅在事务中第一次执行快照读时生成ReadView,后续复用该ReadView。
*/
1
2
3
4
5
6

# 3. MVCC实现原理

/*
MVCC是通过在每行记录后面保存两个隐藏的列来实现的。这两个列,一个保存了行的创建时间,一个保存行的过期时间(或删除时间)。当然存储的并不是实际的时间值,而是系统版本号(system version number)。
每开始一个新的事务,系统版本号都会自动递增。事务开始时刻的系统版本号会作为事务的版本号,用来和查询到的每行记录的版本号进行比较

SELECT

InnoDB会根据以下两个条件检查每行记录:

InnoDB只查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号),这样可以确保事务读取的行,要么是在事务开始前已经存在的,要么是事务自身插入或者修改过的。
行的删除版本要么未定义,要么大于当前事务版本号。这可以确保事务读取到的行,在事务开始之前未被删除。
只有符合上述两个条件的记录,才能返回作为查询结果

INSERT
    InnoDB为新插入的每一行保存当前系统版本号作为行版本号。

DELETE
    InnoDB为删除的每一行保存当前系统版本号作为行删除标识。

UPDATE
    InnoDB为插入一行新记录,保存当前系统版本号作为行版本号,同时保存当前系统版本号到原来的行作为行删除标识。
    
保存这两个额外系统版本号,使大多数读操作都可以不用加锁。这样设计使得读数据操作很简单,性能很好,并且也能保证只会读取到符合标准的行,不足之处是每行记录都需要额外的存储空间,需要做更多的行检查工作,以及一些额外的维护工作

*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 3.1 RC隔离级别
/*
RC隔离级别下,在事务中每一次执行快照读时都会生成一个ReadView。
*/
1
2
3

read view RC级别访问事务版本链数据 image

/*
上图是在RC隔离级别下进行读的过程.
上图第一次最终读取到的是事务id=2的数据:
    当前事务id=5; 活跃的事务id集合={3,4,5};预分配的事务id=6;所以按照上述规则,不是当前事务修改的数据,事务3,4都还没有提交,只能找到事务id=2的数据.
上图第二次最终读取到的是事务id=2的数据:
    当前事务id=5; 活跃的事务id集合={4,5};预分配的事务id=6;所以按照上述规则,不是当前事务修改的数据,事务id=3小于当前最小的事务id=4,只能找到事务id=3的数据.
*/
1
2
3
4
5
6
7
# 3.2 RR隔离级
/*
1) RR 是可重复读,在一个事务中,执行两次相同的select语句,查询到的结果是一样的,在RR隔离级别下,仅在事务中第一次执行快照读时生成ReadView,后续复用该ReadView

2) 在RR隔离级别下,只是在事务中第一次快照读时生成ReadView,后续都是复用该ReadView,那么既然ReadView都一样, ReadView的版本链匹配规则也一样, 那么最终快照读返回的结果也是一样的

3) MVCC的实现原理就是通过 InnoDB表的隐藏字段、UndoLog 版本链、ReadView来实现的。而MVCC + 锁,则实现了事务的隔离性。 而一致性则是由redolog 与 undolog保证
*/
1
2
3
4
5
6
7
Last Updated: 5/5/2023, 2:33:10 AM