关于mysql:MySQL-MVCC实现原理

2次阅读

共计 9918 个字符，预计需要花费 25 分钟才能阅读完成。

MVCC (Multiversion Concurrency Control)，多版本并发管制。顾名思义，MVCC 是通过数据行的多个版本治理实现数据库的并发管制。这项技术使得在 InnoDB 的事务隔离级别下执行一致性读操作有了保障。换言之，就是为了查问一些正在被另一个事务更新的行，并且能够看到它们被更新之前的值，这样在做查问的时候就不必期待另一个事务开释锁。

MVCC 没有正式的规范，在不同的 DBMS 中 MVCC 的实现形式可能是不同的，也不是广泛应用的。本文解说 InnoDB 中 MVCC 的实现机制（MySQL 其它的存储引擎并不反对它）。

MVCC 在 MySQL InnoDB 中的实现次要是为了进步数据库并发性能，用更好的形式去解决读 - 写抵触，做到即便有读写抵触时，也能做到不加锁，非阻塞并发读，而这个读指的就是快照读，而非以后读。以后读实际上是一种加锁的操作，是乐观锁的实现。而 MVCC 实质是采纳乐观锁思维的一种形式。

快照读又叫一致性读，读取的是快照数据。不加锁的简略的 SELECT 都属于快照读，即不加锁的非阻塞读。比方这样：

SELECT * FROM player WHERE ...

之所以呈现快照读的状况，是基于进步并发性能的思考，快照读的实现是基于 MVCC，它在很多状况下，防止了加锁操作，升高了开销。既然是基于多版本，那么快照读可能读到的并不一定是数据的最新版本，而有可能是之前的历史版本。快照读的前提是隔离级别不是串行级别，串行级别下的快照读会进化成以后读。

以后读读取的是记录的最新版本（最新数据，而不是历史版本的数据 )，读取时还要保障其余并发事务不能批改以后记录，会对读取的记录进行加锁。加锁的 SELECT，或者对数据进行增删改都会进行以后读。比方：

SELECT * FROM student LOCK IN SHARE MODE; #共享锁
SELECT * FROM student FOR UPDATE;         #排他锁
INSERT INTO student values ...        #排他锁
DELETE FROM student WHERE ...        #排他锁
UPDATE student SET ...         #排他锁

对于应用 InnoDB 存储引擎的表来说，它的聚簇索引记录中都蕴含两个必要的暗藏列。

trx_id：每次一个事务对某条聚簇索引记录进行改变时，都会把该事务的事务 id 赋值给 trx_id 暗藏列。

roll_pointer：每次对某条聚簇索引记录进行改变时，都会把旧的版本写入到 undo 日志中，而后这个暗藏列就相当于一个指针，能够通过它来找到该记录批改前的信息。

举例: student 表数据如下


SELECT * FROM student ;
/*
+----+--------+--------+
| id | name   | class  |
+----+--------+--------+
|  1 | 张三   | 一班    |
+----+--------+--------+
1 row in set (0.07 sec)
*/

假如插入该记录的事务 id 为 8，那么此刻该条记录的示意图如下所示:

insert undo 只在事务回滚时起作用，当事务提交后，该类型的 undo 日志就没用了，它占用的 Undo Log Segment 也会被零碎回收（也就是该 undo 日志占用的 Undo 页面链表要么被重用，要么被开释 )。

假如之后两个事务 id 别离为 10、20 的事务对这条记录进行 UPDATE 操作，操作流程如下:

能不能在两个事务中穿插更新同一条记录呢?

不能! 这就是一个事务批改了另一个未提交事务批改过的数据，脏写。

InnoDB 应用锁来保障不会有脏写状况的产生，也就是在第一个事务更新了某条记录后，就会给这条记录加锁，另一个事务再次更新时就须要期待第一个事务提交了，把锁开释之后才能够持续更新。

每次对记录进行改变，都会记录一条 undo 日志，每条 undo 日志也都有一个 roll_pointer 属性（INSERT 操作对应的 undo 日志没有该属性，因为该记录并没有更早的版本 )，能够将这些 undo 日志都连起来，串成一个链表:

对该记录每次更新后，都会将旧值放到一条 undo 日志中，就算是该记录的一个旧版本，随着更新次数的增多，所有的版本都会被 roll_pointer 属性连接成一个链表，把这个链表称之为版本链，版本链的头节点就是以后记录最新的值。每个版本中还蕴含生成该版本时对应的事务 id。

在 MVCC 机制中，多个事务对同一个行记录进行更新会产生多个历史快照，这些历史快照保留在 Undo Log 里。如果一个事务想要查问这个行记录，须要读取哪个版本的行记录呢? 这时就须要用到 ReadView 了，它帮咱们解决了行的可见性问题。

ReadView 就是事务在应用 MVCC 机制进行快照读操作时产生的读视图。当事务启动时，会生成数据库系统以后的一个快照，InnoDB 为每个事务结构了一个数组，用来记录并保护零碎以后沉闷事务的 ID(“沉闷”指的就是，启动了但还没提交）。

应用 READ UNCONNMITTED 隔离级别的事务，因为能够读到未提交事务批改过的记录，所以间接读取记录的最新版本就好了。

应用 SERIALIZABLE 隔离级别的事务，InnoDB 规定应用加锁的形式来拜访记录。

应用 READ COMMITTED 和 REPEATABLE READ 隔离级别的事务，都必须保障读到曾经提交了的事务批改过的记录。如果另一个事务曾经批改了记录然而尚未提交，是不能间接读取最新版本的记录的，外围问题就是须要判断一下版本链中的哪个版本是以后事务可见的，这是 ReadView 要解决的次要问题。

这个 ReadView 中次要蕴含 4 个比拟重要的内容，别离如下：

creator_trx_id，创立这个 Read View 的事务 ID。

阐明：只有在对表中的记录做改变时（执行 INSERT、DELETE、UPDATE 这些语句时）才会为事务调配事务 id，否则在一个只读事务中的事务 id 值都默认为 0。

trx_ids，示意在生成 ReadView 时以后零碎中沉闷的读写事务的事务 id 列表。

up_limit_id，沉闷的事务中最小的事务 ID。

low_limit_id，示意生成 ReadView 时零碎中应该调配给下一个事务的 id 值。low_limit_id 是零碎最大的事务 id 值，这里要留神是零碎中的事务 id，须要区别于正在沉闷的事务 ID。

留神: low_limit_id 并不是 trx_ids 中的最大值，事务 id 是递增调配的。比方，当初有 id 为 1，2，3 这三个事务，之后 id 为 3 的事务提交了。那么一个新的读事务在生成 ReadView 时，trx_ids 就包含 1 和 2，up_limit_id 的值就是 1，low_limit_id 的值就是 4。

举例:

trx_ids 为 trx2、trx3、trx5 和 trx8 的汇合，零碎的最大事务 ID (low_limit_id) 为 trx8+1(如果之前没有其余的新增事务)，沉闷的最小事务 ID (up_limit_id) 为 trx2。

有了这个 ReadView，这样在拜访某条记录时，只须要依照下边的步骤判断记录的某个版本是否可见。

如果被拜访版本的 trx_id 属性值与 ReadView 中的 creator_trx_id 值雷同，意味着以后事务在拜访它本人批改过的记录，所以该版本能够被以后事务拜访。20 能够拜访本人

如果被拜访版本的 trx_id 属性值小于 ReadView 中的 up_limit_id 值，表明生成该版本的事务在以后事务生成 ReadView 前曾经提交，所以该版本能够被以后事务拜访。

如果被拜访版本的 trx_id 属性值大于或等于 ReadView 中的 low_limit_id 值，表明生成该版本的事务在以后事务生成 ReadView 后才开启，所以该版本不能够被以后事务拜访。

如果被拜访版本的 trx_id 属性值在 ReadView 的 up_limit_id 和 low_limit_id 之间，那就须要判断一下 trx_id 属性值是不是在 trx_ids 列表中。

如果在，阐明创立 ReadView 时生成该版本的事务还是沉闷的，该版本不能够被拜访。

如果不在，阐明创立 ReadView 时生成该版本的事务曾经被提交，该版本能够被拜访。

理解了这些概念之后，来看下当查问一条记录的时候，零碎如何通过 MVCC 找到它：

首先获取事务本人的版本号，也就是事务 ID；

获取 ReadView；

查问失去的数据，而后与 ReadView 中的事务版本号进行比拟；

如果不合乎 ReadView 规定，就须要从 Undo Log 中获取历史快照；

最初返回合乎规定的数据。

如果某个版本的数据对以后事务不可见的话，那就顺着版本链找到下一个版本的数据，持续依照上边的步骤判断可见性，依此类推，直到版本链中的最初一个版本。如果最初一个版本也不可见的话，那么就意味着该条记录对该事务齐全不可见，查问后果就不蕴含该记录。InnoDB 中，MVCC 是通过 Undo Log + Read View 进行数据读取，Undo Log 保留了历史快照，而 Read View 规定帮咱们判断以后版本的数据是否可见。在隔离级别为读已提交（Read Committed）时，一个事务中的每一次 SELECT 查问都会从新获取一次 Read View。

如表所示：

留神，此时同样的查问语句都会从新获取一次 Read View，这时如果 Read View 不同，就可能产生不可反复读或者幻读的状况。

当隔离级别为可反复读的时候，就防止了不可反复读，这是因为一个事务只在第一次 SELECT 的时候会获取一次 Read View，而前面所有的 SELECT 都会复用这个 Read View，如下表所示:

假如当初 student 表中只有一条由事务 id 为 8 的事务插入的一条记录：

SELECT * FROM student ;
/*
+----+--------+--------+
| id | name   | class  |
+----+--------+--------+
|  1 | 张三   | 一班    |
+----+--------+--------+
1 row in set (0.07 sec)
*/

MVCC 只能在 READ COMMITTED 和 REPEATABLE READ 两个隔离级别下工作。READ COMMITTED 和 REPEATABLE READ 生成 ReadView 的机会是不同的。

READ COMMITTED：每次读取数据前都生成一个 ReadView
当初有两个 事务 id 别离为 10、20 的事务在执行
# Transaction 10
BEGIN;
UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;

# Transaction 20
BEGIN;
# 更新了一些别的表的记录 (为了调配事务 id)

阐明: 事务执行过程中，只有在第一次真正批改记录时 (比方应用 INSERT、DELETE、UPDATE 语句)，才会被调配一个独自的事务 id，这个事务 id 是递增的。所以咱们才在事务 20 中更新一些别的表的记录，目标是让它调配事务 id。

此刻，表 student 中 id 为 1 的记录失去的版本链表如下所示:

假如当初有一个应用 READ COMMITTED 隔离级别的事务开始执行

# 应用 READ COMMITTED 隔离级别的事务

BEGIN;
# SELECT1：Transaction 10、20 未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值为 '张三'

这个·SELECT1·的执行过程如下:

步骤 1：在执行 SELECT 语句时会学生成一个 ReadView，ReadView 的 trx_ids 列表的内容就是 [10，20],up_limit_id 为 10, low_limit_id 为 21, creator_trx_id 为 0。

步骤 2：从版本链中筛选可见的记录，从图中看出，最新版本的列 name 的内容是’王五’，该版本的 trx_id 值为 10，在 trx_ids 列表内，所以不合乎可见性要求，依据 roll_pointer 跳到下一个版本

步骤 3：下一个版本的列 name 的内容是’李四’，该版本的 trx_id 值也为 10，也在 trx_ids 列表内，所以也不符合要求，持续跳到下一个版本

步骤 4：下一个版本的列 name 的内容是’张三’，该版本的 trx_id 值为 8，小于 ReadView 中的 up_limit_id 值 10，所以这个版本是符合要求的，最初返回给用户的版本就是这条列 name 为‘张三’的记录

之后，把事务 id 为 10 的事务提交一下：


# Transaction 10
BEGIN;

UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;

COMMIT;

而后再到事务 id 为 20 的事务中更新一下表 student 中 id 为 1 的记录：


# Transaction 20
BEGIN;
# 更新了一些别的表的记录
...
UPDATE student SET name="钱七" WHERE id=1;
UPDATE student SET name="宋八" WHERE id=1;

此刻，表 student 中 id 为 1 的记录的版本链就长这样：

而后再到方才应用 READ COMMITTED 隔离级别的事务中持续查找这个 id 为 1 的记录，如下：


# 应用 READ COMMITTED 隔离级别的事务
BEGIN;

# SELECT1：Transaction 10、20 均未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值为 '张三'

# SELECT2：Transaction 10 提交，Transaction 20 未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值为 '王五'

这个 SELECT2 的执行过程如下:

步骤 1∶在执行 SELECT 语句时会又会独自生成一个 ReadView，该 ReadView 的 trx_ids 列表的内容就是 [20]，up_limit_id 为 20，low_limit_id 为 21, creator_trx_id 为 0。

步骤 2: 从版本链中筛选可见的记录，从图中看出，最新版本的列 name 的内容是’宋八’，该版本的 trx_id 值为 20，在 trx_ids 列表内，所以不合乎可见性要求，依据 roll_pointer 跳到下一个版本。

步骤 3∶下一个版本的列 name 的内容是‘钱七’，该版本的 trx_id 值为 20，也在 trx_ids 列表内，所以也不符合要求，持续跳到下一个版本

步骤 4∶下一个版本的列 name 的内容是’王五’，该版本的 trx_id 值为 10，小于 ReadView 中的 up_limit_id 值 20，所以这个版本是符合要求的，最初返回给用户的版本就是这条列 name 为’王五’的记录。

以此类推，如果之后事务 id 为 20 的记录也提交了，再次在应用 READ COMMITED 隔离级别的事务查问表 student 中 id 值为 1 的记录时，失去的后果就是 ’ 宋八 ’ 了，具体流程咱们就不剖析了。

强调: 应用 READ COMMITTED 隔离级别的事务在每次查问开始时都会生成一个独立的 ReadView

应用 REPEATABLE READ 隔离级别的事务来说，只会在第一次执行查问语句时生成一个 ReadView，之后的查问就不会反复生成了。

比方，零碎里有两个事务 id 别离为 10、20 的事务在执行：


# Transaction 10
BEGIN;
UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;

# Transaction 20
BEGIN;
# 更新了一些别的表的记录
...

此刻，表 student 中 id 为 1 的记录失去的版本链表如下所示：

假如当初有一个应用 REPEATABLE READ 隔离级别的事务开始执行：


# 应用 REPEATABLE READ 隔离级别的事务
BEGIN;

# SELECT1：Transaction 10、20 未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值为 '张三'

这个 SELECT1 的执行过程如下:

步骤 1: 在执行·SELECT·语句时会学生成一个 ReadView，ReadView 的 trx_ids 列表的内容就是 [10，20]，up_limit_id 为 10, low_limit_id 为 21, creator_trx_id 为 0。

步骤 2: 而后从版本链中筛选可见的记录，从图中看出，最新版本的列 name 的内容是’王五’，该版本的 trx_id 值为 10，在 trx_ids 列表内，所以不合乎可见性要求，依据 roll_pointer 跳到下一个版本。

步骤 3: 下一个版本的列 name 的内容是’李四’，该版本的 trx_id 值也为 10，也在 trx_ids 列表内，所以也不符合要求，持续跳到下一个版本。

步骤 4∶下一个版本的列 name 的内容是’张三’，该版本的 trx_id 值为 8，小于 ReadView 中的 up_limit_id 值 10，所以这个版本是符合要求的，最初返回给用户的版本就是这条列 name 为’张三’的记录

之后，咱们把事务 id 为 10 的事务提交一下，就像这样:


# Transaction 10
BEGIN;

UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;

COMMIT;

而后再到事务 id 为 20 的事务中更新一下表 student 中 id 为 1 的记录：


# Transaction 20
BEGIN;

# 更新了一些别的表的记录
...
UPDATE student SET name="钱七" WHERE id=1;
UPDATE student SET name="宋八" WHERE id=1;

此刻，表 student 中 id 为 1 的记录的版本链长这样：

而后再到方才应用 REPEATABLE READ 隔离级别的事务中持续查找这个 id 为 1 的记录，如下：


# 应用 REPEATABLE READ 隔离级别的事务
BEGIN;

# SELECT1：Transaction 10、20 均未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值为 '张三'

# SELECT2：Transaction 10 提交，Transaction 20 未提交
SELECT * FROM student WHERE id = 1; # 失去的列 name 的值仍为 '张三'

SELECT2 的执行过程如下:

步骤 1: 因为以后事务的隔离级别为 REPEATABLE READ，而之前在执行 SELECT1 时曾经生成过 ReadView 了，所以此时间接复用之前的 ReadView，之前的 ReadView 的 trx_ids 列表的内容就是 [10，20]，up_limit_id 为 10，low_limit_id 为 21, creator_trx_id 为 0。

步骤 2: 而后从版本链中筛选可见的记录，从图中能够看出，最新版本的列 name 的内容是’宋八’，该版本的 trx_id 值为 20，在 trx_ids 列表内，所以不合乎可见性要求，依据 roll_pointer 跳到下一个版本

步骤 3: 下一个版本的列 name 的内容是’钱七’，该版本的 trx_id 值为 20，也在 trx_ids 列表内，所以也不符合要求，持续跳到下一个版本

步骤 4∶下一个版本的列 name 的内容是’王五’，该版本的 trx_id 值为 10，而 trx_ids 列表中是蕴含值为 10 的事务 id 的，所以该版本也不符合要求，同理下一个列 name 的内容是‘李四’的版本也不符合要求。持续跳到下一个版本

步骤 5: 下一个版本的列 name 的内容是’张三’，该版本的 trx_id 值为 8，小于 ReadView 中的 up_limit_id 值 10，所以这个版本是符合要求的，最初返回给用户的版本就是这条列 c 为‘张三’的记录。

两次 SELECT 查问失去的后果是反复的，记录的列 c 值都是‘张三 ’，这就是可反复读的含意。如果咱们之后再把事务 id 为 20 的记录提交了，而后再到方才应用 REPEATABLE READ 隔离级别的事务中持续查找这个 id 为 1 的记得到的后果还是‘张三 ’。

接下来阐明 InnoDB 是如何解决幻读的。

假如当初表 student 中只有一条数据，数据内容中，主键 id=1，暗藏的 trx_id=10，它的 undo log 如下图所示。

假如当初有事务 A 和事务 B 并发执行，事务 A 的事务 id 为 20，事务 B 的事务 id 为 30。

步骤 1：事务 A 开始第一次查问数据，查问的 SQL 语句如下

select * from student where id >= 1;

在开始查问之前，MySQL 会为事务 A 产生一个 ReadView，此时 ReadView 的内容如下：trx_ids=[20,30] up_limit_id=20，low_limit_id=31，creator_trx_id=20。

因为此时表 student 中只有一条数据，且合乎 where id>=1 条件，因而会查问进去。而后依据 ReadView 机制，发现该行数据的 trx_id=10，小于事务 A 的 ReadView 里 up_limit_id，这示意这条数据是事务 A 开启之前，其余事务就曾经提交了的数据，因而事务 A 能够读取到。

论断：事务 A 的第一次查问，能读取到一条数据，id=1。

步骤 2：接着事务 B(trx_id=30)，往表 student 中新插入两条数据，并提交事务

insert into student(id,name) values(2,'李四');
insert into student(id,name) values(3,'王五');

此时表 student 中就有三条数据了，对应的 undo 如下图所示：

步骤 3：接着事务 A 开启第二次查问，依据可反复读隔离级别的规定，此时事务 A 并不会再从新生成 ReadView。此时表 student 中的 3 条数据都满足 where id>=1 的条件，因而会先查进去。而后依据 ReadView 机制，判断每条数据是不是都能够被事务 A 看到。

1）首先 id=1 的这条数据，后面曾经说过了，能够被事务 A 看到。

2）而后是 id=2 的数据，它的 trx_id=30，此时事务 A 发现，这个值处于 up_limit_id 和 low_limit_id 之间，因而还须要再判断 30 是否处于 trx_ids 数组内。因为事务 A 的 trx_ids=[20,30]，因而在数组内，这示意 id=2 的这条数据是与事务 A 在同一时刻启动的其余事务提交的，所以这条数据不能让事务 A 看到

3）同理，id=3 的这条数据，trx_id 也为 30，因而也不能被事务 A 看见

论断：最终事务 A 的第二次查问，只能查问出 id=1 的这条数据。这和事务 A 的第一次查问的后果是一样的，因而没有呈现幻读景象，所以说在 MySQL 的可反复读隔离级别下，不存在幻读问题。

这里介绍了 MVCC 在 READ COMMITTD、REPEATABLE READ 这两种隔离级别的事务在执行快照读操作时拜访记录的版本链的过程。这样使不同事务的读 - 写、写 - 读操作并发执行，从而晋升零碎性能。

外围点在于 ReadView 的原理，READ COMMITTD、REPEATABLE READ 这两个隔离级别的一个很大不同就是生成 ReadView 的机会不同：

READ COMMITTD 在每一次进行一般 SELECT 操作前都会生成一个 ReadView
REPEATABLE READ 只在第一次进行一般 SELECT 操作前生成一个 ReadView，之后的查问操作都重复使用这个 ReadView 就好了

阐明: 之前说执行 DELETE 语句或者更新主键的 UPDATE 语句并不会立刻把对应的记录齐全从页面中删除，而是执行一个所谓的 delete mark 操作，相当于只是对记录打上了一个删除标记位，这次要就是为 MVCC 服务的。

通过 MVCC 能够解决:

1. 读写之间阻塞的问题。通过 MVCC 能够让读写相互不阻塞，即读不阻塞写，写不阻塞读，这样就能够晋升事务并发解决能力

2. 升高了死锁的概率。这是因为 MVCC 采纳了乐观锁的形式，读取数据时并不需要加锁，对于写操作，也只锁定必要的行

3. 解决快照读的问题。当查询数据库在某个工夫点的快照时，只能看到这个工夫点之前事务提交更新的后果，而不能看到这个工夫点之后事务提交的更新后果

文 / Eric

正文完

mysql

发表至： mysql

2023-03-21

0

关于mysql:MySQL分区表

关于mysql:mysql安装配置教程

关于mysql:Mysql-80-OGG21C-安装使用

关于mysql:MySQL间隙锁nextkey锁

关于算法:浅谈活动场景下的图算法在反作弊应用

关于mysql:MySQL-MVCC实现原理

1. 概念

2. 快照读和以后读

2.1 快照读

2.2 以后读

3.MVCC 实现

3.1 暗藏字段

3.2 Undo Log 版本链

3.3 ReadView

3.3.1 设计思路

3.3.2 ReadView 的规定

3.4 MVCC 整体操作流程

4.MVCC 示例

4.1 READ COMMITTED 隔离级别

4.2 REPEATABLE READ 隔离级别

4.3 如何解决幻读

5. 总结

站内搜索

关于mysql:MySQL-MVCC实现原理

​1. 概念

2. 快照读和以后读

2.1 快照读

2.2 以后读

3.MVCC 实现

3.1 暗藏字段

3.2 Undo Log 版本链

3.3 ReadView

3.3.1 设计思路

3.3.2 ReadView 的规定

3.4 MVCC 整体操作流程

4.MVCC 示例

4.1 READ COMMITTED 隔离级别

4.2 REPEATABLE READ 隔离级别

4.3 如何解决幻读

5. 总结

站内搜索

1. 概念