一、基础概念
1. MVCC的含义
MVCC (Multiversion Concurrency Control),即多版本并发控制技术,它是通过读取某个时间点的快照数据, 来降低并发事务冲突而引起的锁等待, 从而提高并发性能的一种机制.
MVCC 的基本思路是对数据库的任何修改都不会直接覆盖之前的数据,而是产生一个新版副本与老版本共存,以此达到读取时可以完全不加锁的目的。
MVCC只在 READ COMMITTED 和 REPEATABLE READ 两个隔离级别下工作,其他两个隔离级别够和MVCC不兼容.
因为 READ UNCOMMITTED 总是读取最新的数据行, 而不是符合当前事务版本的数据行。
而 SERIALIZABLE 则会对所有读取的行都加锁。
MVCC 是只针对“读 + 写”场景的优化,如果是两个事务同时修改数据,即“写 + 写”的情况,那就没有多少优化的空间了,加锁几乎是唯一可行的解决方案。
读写数据时通过一种类似快照的方式将数据保存下来,这样读锁就和写锁不冲突了,不同的事务session会看到自己特定版本的数据版本链(undo log),它使得大部分支持行锁的事务引擎,不再单纯的使用行锁来进行数据库的并发控制,取而代之的是把数据库的行锁与行的多个版本结合起来,只需要很小的开销,就可以实现非锁定读,从而大大提高数据库系统的并发性能。
自己理解:就是用版本号而不是锁,已达到并发下的读写。
2. MVCC的意义
这样设计使得读数据操作很简单,性能很好,并且也能保证只会读取到符合标准的行。
不足之处是每行记录都需要额外的存储空间,需要做更多的行检查工作,以及一些额外的维护工作。
MVCC是事务隔离性的底层实现原理之一
那么读提交和可重复读的底层MVCC有何实现差异?
读提交的逻辑和可重复读的逻辑类似,它们最主要的区别是:
- 在可重复读隔离级别下,只需要在事务开始的时候创建一致性视图,之后当前事务里的其他查询都共用这个一致性视图;
- 在读提交隔离级别下,每一个语句执行前都会重新算出一个新的视图
可重复读的核心就是一致性读(consistent read);而事务更新数据的时候,只能用当前读。如果当前的记录的行锁被其他事务占用的话,就需要进入锁等待。
二.实现原理
在可重复读隔离级别下,事务在启动的时候就“拍了个快照”。注意,这个快照是基于整库的。
InnoDB的MVCC,是通过在每行记录后面保存两个隐藏的列来实现的。
每开始一个新的事务,系统版本号都会自动递增。事务开始时刻的系统版本号会作为事务的版本号,用来和查询到的每行记录的版本号进行比较。下面看一下在 REPEATABLEREAD 隔离级别下,MVCC具体是如何操作的。
SELECT
InnoDB会根据以下两个条件检查每行记录:
a.InnoDB 只查找版本早于当前事务版本的数据行(也就是,行的系统版本号小于或等于事务的系统版本号),这样可以确保事务读取的行,要么是在事务开始前已经存在的,要么是事务自身插人或者修改过的。
b,行的删除版本要么未定义,要么大于当前事务版本号。这可以确保事务读取到的行,在事务开始之前未被删除。
只有符合上述两个条件的记录,才能返回作为查询结果INSERT
InnoDB 为新插人的每一行保存当前系统版本号作为行版本号DELETE
InnoDB 为删除的每一行保存当前系统版本号作为行删除标识。UPDATE
InnoDB 为插入一行新记录,保存当前系统版本号作为行版本号,同时保存当前系统版本号到原来的行作为行删除标识。
1.聚簇索引隐藏列
在数据库表的记录中,每一个记录都会添加三个字段:
- DB_TRX_ID:6个字节,表示当前修改本记录的事务ID
- DB_ROLL_PTR :7 个字节,回滚指针,指向回滚段中的 undo log record,用于找出这个记录的上个版本修改的数据。
- DB_ROW_ID:6 个字节,一个单调递增的 ID,确定表中记录的唯一性。
每行数据也都是有多个版本的,每次事务更新数据的时候,都会生成一个新的数据版本,并且把 transaction id 赋值给这个数据版本的事务 ID,记为 row trx_id。同时,旧的数据版本要保留,并且在新的数据版本中,能够有信息可以直接拿到它。
也就是说,数据表中的一行记录,其实可能有多个版本 (row),每个版本有自己的 row trx_id。
如图 2 所示,就是一个记录被多个事务连续更新后的状态。
图 2 行状态变更图
图中虚线框里是同一行数据的 4 个版本,当前最新版本是 V4,k 的值是 22,它是被 transaction id 为 25 的事务更新的,因此它的 row trx_id 也是 25。
你可能会问,前面的文章不是说,语句更新会生成 undo log(回滚日志)吗?那么,undo log 在哪呢?
实际上,图 2 中的三个虚线箭头,就是 undo log;而 V1、V2、V3 并不是物理上真实存在的,而是每次需要的时候根据当前版本和 undo log 计算出来的。比如,需要 V2 的时候,就是通过 V4 依次执行 U3、U2 算出来。
2.一致性视图(read-view)
按照可重复读的定义,一个事务启动的时候,能够看到所有已经提交的事务结果。但是之后,这个事务执行期间,其他事务的更新对它不可见。
因此,一个事务只需要在启动的时候声明说,“以我启动的时刻为准,如果一个数据版本是在我启动之前生成的,就认;如果是我启动以后才生成的,我就不认,我必须要找到它的上一个版本”。
当然,如果“上一个版本”也不可见,那就得继续往前找。还有,如果是这个事务自己更新的数据,它自己还是要认的。
在实现上, InnoDB 为每个事务构造了一个数组,用来保存这个事务启动瞬间,当前正在“活跃”的所有事务 ID。
“活跃”指的就是,启动了但还没提交。
数组里面事务 ID 的最小值记为低水位,当前系统里面已经创建过的事务 ID 的最大值加 1 记为高水位。
这个视图数组和高水位,就组成了当前事务的一致性视图(read-view)
而数据版本的可见性规则,就是基于数据的 row trx_id 和这个一致性视图的对比结果得到的。这个视图数组把所有的 row trx_id 分成了几种不同的情况。
这样,对于当前事务的启动瞬间来说,一个数据版本的 row trx_id,有以下几种可能:
- 如果落在绿色部分,表示这个版本是已提交的事务或者是当前事务自己生成的,这个数据是可见的;
- 如果落在红色部分,表示这个版本是由将来启动的事务生成的,是肯定不可见的;
- 如果落在黄色部分,就需要版本对比了。
那就包括两种情况
a. 若 row trx_id 在数组中,表示这个版本是由还没提交的事务生成的,不可见;但如果当前是自己的事务,是可见的。
b. 若row trx_id 不在数组中,表示这个版本是已经提交了的事务生成的,可见。(一致性视图再rm级别下是会更新变化的,也只有rm级别才会这种场景)
3.一致性读(consistent read)
又称快照读,读取的是undo log中的数据,可能是数据的历史版本,no-locking,所以是非阻塞的读取操作,对应为一般的select 语句。
4.当前读(current read)
读取的是记录的最新版本,可能是其他事务提交后的值, 加锁保证事务隔离性,如读取到的行其他事务已经更新但还没有提交事务,那么会进入锁等待。
主要发生在update 语句,除了 update 语句外,select 语句如果加锁,也是当前读。
而对于一般的查询语句则使用的是一致性读,即不会读到其他事务提交后的值。
5. 数据库行纪录的更新底层机制
1.初始数据行
F1~F6是某行列的名字,1~6是其对应的数据。后面三个隐含字段分别对应该行的事务号和回滚指针,假如这条数据是刚INSERT的,可以认为ID为1,其他两个字段为空。
2.事务1更改该行的各字段的值
当事务1更改该行的值时,会进行如下操作:
- 用排他锁锁定该行
- 记录redo log
- 把该行修改前的值Copy到undo log,即上图中下面的行
- 修改当前行的值,填写事务编号,使回滚指针指向undo log中的修改前的行
3.事务2修改该行的值
与事务1相同,此时undo log,中有有两行记录,并且通过回滚指针连在一起。
因此,如果undo log一直不删除,则会通过当前记录的回滚指针回溯到该行创建时的初始内容。
所幸的时在Innodb中存在purge线程,它会查询那些比现在最老的活动事务(即还未提交的事务)还早的undo log,并删除它们,从而保证undo log文件不至于无限增长。
即事务一旦提交了,所对应的undo log文件就失去了存在的意义
6. 删除的底层实现机制
将所在行的数据复制一份,然后将事务ID更新为删除操作的事务ID。并将新的事务ID的头信息record header里的删除标示delete_flag标记置为true,当读起的时候会检查头信息,如果标记为true,则不返回对应的数据。
可见数据库底层操作也是类似逻辑删除。
三.实战分析
1.场景一
我给你举一个例子吧。下面是一个只有两行的表的初始化语句。
mysql> CREATE TABLE `t` (
`id` int(11) NOT NULL,
`k` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
insert into t(id, k) values(1,1),(2,2);
三个并发事务执行顺序如下
在这个例子中,事务 C 没有显式地使用 begin/commit,表示这个 update 语句本身就是一个事务,语句完成的时候会自动提交。事务 B 在更新了行之后查询 ; 事务 A 在一个只读事务中查询,并且时间顺序上是在事务 B 的查询之后。
这里,我们不妨做如下假设:
1.事务 A 开始前,系统里面只有一个活跃事务 ID 是 99;
2.事务 A、B、C 的版本号分别是 100、101、102,且当前系统里只有这四个事务;
3.三个事务开始前,(1,1)这一行数据的 row trx_id 是 90。
这样,事务 A 的视图数组就是 [99,100], 事务 B 的视图数组是 [99,100,101], 事务 C 的视图数组是 [99,100,101,102]。
在可重复读隔离级别下
为了简化分析,我先把其他干扰语句去掉,只画出跟事务 A 查询逻辑有关的操作:
图 4 事务 A 查询数据逻辑图
从图中可以看到,第一个有效更新是事务 C,把数据从 (1,1) 改成了 (1,2)。这时候,这个数据的最新版本的 row trx_id 是 102,而 90 这个版本已经成为了历史版本。
第二个有效更新是事务 B,把数据从 (1,2) 改成了 (1,3)。这时候,这个数据的最新版本(即 row trx_id)是 101,而 102 又成为了历史版本。
你可能注意到了,在事务 A 查询的时候,其实事务 B 还没有提交,但是它生成的 (1,3) 这个版本已经变成当前版本了。但这个版本对事务 A 必须是不可见的,否则就变成脏读了。
好,现在事务 A 要来读数据了,它的视图数组是 [99,100]。那么此时事务A的低水位为99,高水位为90+1=91.
当然了,读数据都是从当前版本读起的。所以,事务 A 查询语句的读数据流程是这样的:
- 找到 (1,3) 的时候,判断出 row trx_id=101,比高水位大(开启一致性视图开启的事务),处于红色区域,不可见;
- 接着,找到上一个历史版本,一看 row trx_id=102,比高水位大(开启一致性视图开启的事务),处于红色区域,不可见;
- 再往前找,终于找到了(1,1),它的 row trx_id=90,比低水位小,处于绿色区域,可见。
这样执行下来,虽然期间这一行数据被修改过,但是事务 A 不论在什么时候查询,看到这行数据的结果都是一致的,所以我们称之为一致性读。
这个判断规则是从代码逻辑直接转译过来的,但是正如你所见,用于人肉分析可见性很麻烦。
所以,我来给你翻译一下。一个数据版本,对于一个事务视图来说,除了自己的更新总是可见以外,有三种情况:
版本未提交,不可见;
版本已提交,但是是在视图创建后提交的,不可见;
版本已提交,而且是在视图创建前提交的,可见。
现在,我们用这个规则来判断图 4 中的查询结果,事务 A 的查询语句的视图数组是在事务 A 启动的时候生成的,这时候:
(1,3) 还没提交,属于情况 1,不可见;
(1,2) 虽然提交了,但是是在视图数组创建之后提交的,属于情况 2,不可见;
(1,1) 是在视图数组创建之前提交的,可见。
你看,去掉数字对比后,只用时间先后顺序来判断,分析起来是不是轻松多了。
所以,后面我们就都用这个规则来分析。
事务 B的查询
事务 B 的视图数组是 [99,100,101],低水位是99,高水位为90+1=91
事务 B在更新后的查询语句的读数据流程是这样的():
找到 (1,3) 的时候,判断出 row trx_id=101,发现是自己的事务ID,则可见,顾查询的值为3。
细心的同学可能有疑问了:事务 B 的 update 语句,如果按照一致性读,好像结果不对哦?
你看图 5 中,事务 B 的视图数组是先生成的,之后事务 C 才提交,不是应该看不见 (1,2) 吗,怎么能算出 (1,3) 来?
是的,如果事务 B 在更新之前查询一次数据,这个查询返回的 k 的值确实是 1。
但是,当它要去更新数据的时候,就不能再在历史版本上更新了,否则事务 C 的更新就丢失了。因此,事务 B 此时的 set k=k+1 是在(1,2)的基础上进行的操作。
所以,这里就用到了这样一条规则:更新数据都是先读后写的,而这个读,只能读当前的值,称为“当前读”(current read)。
因此,在更新的时候,当前读拿到的数据是 (1,2),更新后生成了新版本的数据 (1,3),这个新版本的 row trx_id 是 101。
所以,在执行事务 B 查询语句的时候,一看自己的版本号是 101,最新数据的版本号也是 101,是自己的更新,可以直接使用,所以查询得到的 k 的值是 3。
这里我们提到了一个概念,叫作当前读。其实,除了 update 语句外,select 语句如果加锁,也是当前读。
所以,如果把事务 A 的查询语句 select * from t where id=1 修改一下,加上 lock in share mode 或 for update,也都可以读到版本号是 101 的数据,返回的 k 的值是 3。下面这两个 select 语句,就是分别加了读锁(S 锁,共享锁)和写锁(X 锁,排他锁)。
mysql> select k from t where id=1 lock in share mode;
mysql> select k from t where id=1 for update;
再往前一步,假设事务 C 不是马上提交的,而是变成了下面的事务 C’,会怎么样呢?
图 6 事务 A、B、C’的执行流程
事务 C’的不同是,更新后并没有马上提交,在它提交前,事务 B 的更新语句先发起了。
前面说过了,虽然事务 C’还没提交,但是 (1,2) 这个版本也已经生成了,并且是当前的最新版本。那么,事务 B 的更新语句会怎么处理呢?
这时候,我们在之前提到的“两阶段锁协议”就要上场了。
事务 C’没提交,也就是说 (1,2) 这个版本上的写锁还没释放,而事务 B 是当前读,必须要读最新版本,而且必须加锁,因此就被锁住了,必须等到事务 C’释放这个锁,才能继续它的当前读。
到这里,我们把一致性读、当前读和行锁就串起来了。
事务 C的查询
事务 C 的视图数组是 [99,100,101,102]。低水位是99,高水位为90+1=91.
事务 C查询语句的读数据流程是这样的:
找到 (1,3) 的时候,判断出 row trx_id=101,大于高水位,不可见。
然后查上一版本,判断row trx_id=102,发现是自己的事务ID,可见。估事务 C查询语句得到的值是2.
那么,我们再看一下,在读提交隔离级别下,事务 A 和事务 B 的查询语句查到的 k,分别应该是多少呢?
在读提交时隔离级别下
下面是读提交时的状态图,可以看到这两个查询语句的创建视图数组的时机发生了变化,就是图中的 read view 框。(注意:这里,我们用的还是事务 C 的逻辑直接提交,而不是事务 C’)
这时,事务 A 的查询语句的视图数组是在执行这个语句的时候创建的,时序上 (1,2)、(1,3) 的生成时间都在创建这个视图数组的时刻之前。但是,在这个时刻:
- (1,3) 还没提交,属于情况 1,不可见;
- (1,2) 提交了,属于情况 3,可见。
所以,这时候事务 A 查询语句返回的是 k=2。
显然地,事务 B 查询结果 k=3。
那么如果用一致性视图的读取规则来计算的话
事务A查询语句的视图为:[100,101] ,低水位是100,此时已提交的事务信息事务ID是102,所以高水位是102+1=103。
读起规则:
首先101小于103,且在未提交事务数组中,不可见。然后102小于103,且不在未提交事务数组中,可见。
事务B查询语句的视图为:[100,101] 此时A未提交事务,C已提交事务。所以低水位是100,高水位是102+1=103。
读起规则:
首先101是当前事务ID,可见。事务 B 查询结果 k=3。
事务C查询语句的视图为:[100,101,102] ,此时A,B,C都未提交事务,所以低水位是100,高水位是90+1=91。并且事务C查询的时候,还没有执行事务B101的更新语句.
读起规则:
首先102是当前事务ID,可见。事务C 查询结果 k=2。
2.场景二
我们创建了一个简单的表 t,并插入一行,然后对这一行做修改。
mysql> CREATE TABLE `t` (
`id` int(11) NOT NULL primary key auto_increment,
`a` int(11) DEFAULT NULL
) ENGINE=InnoDB;
insert into t values(1,2);
这时候,表 t 里有唯一的一行数据 (1,2)。假设,我现在要执行:
|
你会看到这样的结果:
结果显示,匹配 (rows matched) 了一行,修改 (Changed) 了 0 行。
仅从现象上看,MySQL 内部在处理这个命令的时候,可以有以下三种选择:
-
更新都是先读后写的,MySQL 读出数据,发现 a 的值本来就是 2,不更新,直接返回,执行结束;
-
MySQL 调用了 InnoDB 引擎提供的“修改为 (1,2)”这个接口,但是引擎发现值与原来相同,不更新,直接返回;
-
InnoDB 认真执行了“把这个值修改成 (1,2)"这个操作,该加锁的加锁,该更新的更新。
你觉得实际情况会是以上哪种呢?你可否用构造实验的方式,来证明你的结论?进一步地,可以思考一下,MySQL 为什么要选择这种策略呢?
第一个选项是,MySQL 读出数据,发现值与原来相同,不更新,直接返回,执行结束。这里我们可以用一个锁实验来确认。
假设,当前表 t 里的值是 (1,2)。
图 12 锁验证方式
session B 的 update 语句被 blocked 了,加锁这个动作是 InnoDB 才能做的,所以排除选项 1。
第二个选项是,MySQL 调用了 InnoDB 引擎提供的接口,但是引擎发现值与原来相同,不更新,直接返回。有没有这种可能呢?这里我用一个可见性实验来确认。
假设当前表里的值是 (1,2)。
图 13 可见性验证方式
session A的update语句是当前读,所以结果是匹配了一行,但没有结果更新。
session A 的第二个 select 语句是一致性读(快照读),它是不能看见 session B 的更新的。
现在它返回的是 (1,3),表示它看见了某个新的版本,这个版本只能是 session A 自己的 update 语句做更新的时候生成。
所以,我们的答案应该是选项 3,即:InnoDB 认真执行了“把这个值修改成 (1,2)"这个操作,该加锁的加锁,该更新的更新。
然后你会说,MySQL 怎么这么笨,就不会更新前判断一下值是不是相同吗?如果判断一下,不就不用浪费 InnoDB 操作,多去更新一次了?
其实 MySQL 是确认了的。只是在这个语句里面,MySQL 认为读出来的值,只有一个确定的 (id=1), 而要写的是 (a=3),只从这两个信息是看不出来“不需要修改”的。
作为验证,你可以看一下下面这个例子。
图 14 可见性验证方式 -- 对照
这里update语句只查询只匹配了id=1的条件,而a=3因为是一致性读所以匹配不上。
3.场景三
我们再看一个只扫描一行,但是执行很慢的语句。
如图 12 所示,是这个例子的 slow log。可以看到,执行的语句是
|
虽然扫描行数是 1,但执行时间却长达 800 毫秒。
图 12 扫描一行却执行得很慢
是不是有点奇怪呢,这些时间都花在哪里了?
如果我把这个 slow log 的截图再往下拉一点,你可以看到下一个语句,select * from t where id=1 lock in share mode,执行时扫描行数也是 1 行,执行时间是 0.2 毫秒。
图 13 加上 lock in share mode 的 slow log
看上去是不是更奇怪了?按理说 lock in share mode 还要加锁,时间应该更长才对啊。
可能有的同学已经有答案了。如果你还没有答案的话,我再给你一个提示信息,图 14 是这两个语句的执行输出结果。
图 14 两个语句的输出结果
第一个语句的查询结果里 c=1,带 lock in share mode 的语句返回的是 c=1000001。看到这里应该有更多的同学知道原因了。如果你还是没有头绪的话,也别着急。我先跟你说明一下复现步骤,再分析原因。
图 15 复现步骤
你看到了,session A 先用 start transaction with consistent snapshot 命令启动了一个事务,之后 session B 才开始执行 update 语句。
session B 执行完 100 万次 update 语句后,id=1 这一行处于什么状态呢?你可以从图 16 中找到答案。
图 16 id=1 的数据状态
session B 更新完 100 万次,生成了 100 万个回滚日志 (undo log)。
带 lock in share mode 的 SQL 语句,是当前读,因此会直接读到 1000001 这个结果,所以速度很快;而 select * from t where id=1 这个语句,是一致性读,因此需要从 1000001 开始,依次执行 undo log,执行了 100 万次以后,才将 1 这个结果返回。
注意,undo log 里记录的其实是“把 2 改成 1”,“把 3 改成 2”这样的操作逻辑,画成减 1 的目的是方便你看图。
参考资料
1.极客时间《MySQL实战45讲》