mysql-MVCC

一、基础概念

1. MVCC的含义

MVCC (Multiversion Concurrency Control)，即多版本并发控制技术，它是通过读取某个时间点的快照数据， 来降低并发事务冲突而引起的锁等待， 从而提高并发性能的一种机制.

MVCC 的实现,是通过保存数据在某个时间点的快照来实现的。也就是说，不管需要执行多长时间，每个事务看到的数据都是一致的。

根据事务开始的时间不同，每个事务对同一张表，同一时刻看到的数据可能是不一样的。

MVCC只在 READ COMMITTED 和 REPEATABLE READ 两个隔离级别下工作。其他两个隔离级别够和MVCC不兼容.

因为 READ UNCOMMITTED 总是读取最新的数据行, 而不是符合当前事务版本的数据行。

而 SERIALIZABLE 则会对所有读取的行都加锁。

读取数据时通过一种类似快照的方式将数据保存下来，这样读锁就和写锁不冲突了，不同的事务session会看到自己特定版本的数据版本链，它使得大部分支持行锁的事务引擎，不再单纯的使用行锁来进行数据库的并发控制，取而代之的是把数据库的行锁与行的多个版本结合起来，只需要很小的开销,就可以实现非锁定读，从而大大提高数据库系统的并发性能。

自己理解：就是用版本号而不是锁，已达到并发下的读写。

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，有以下几种可能：

1. 如果落在绿色部分，表示这个版本是已提交的事务或者是当前事务自己生成的，这个数据是可见的；
2. 如果落在红色部分，表示这个版本是由将来启动的事务生成的，是肯定不可见的；
3. 如果落在黄色部分，就需要版本对比了。
   那就包括两种情况
   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更改该行的值时，会进行如下操作：

1. 用排他锁锁定该行
2. 记录redo log
3. 把该行修改前的值Copy到undo log，即上图中下面的行
4. 修改当前行的值，填写事务编号，使回滚指针指向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)。假设，我现在要执行：

|---|---------------------------------------|
| | mysql> update t set a=2 where id=1; |

你会看到这样的结果：

结果显示，匹配 (rows matched) 了一行，修改 (Changed) 了 0 行。

仅从现象上看，MySQL 内部在处理这个命令的时候，可以有以下三种选择：

1. 更新都是先读后写的，MySQL 读出数据，发现 a 的值本来就是 2，不更新，直接返回，执行结束；

2. MySQL 调用了 InnoDB 引擎提供的"修改为 (1,2)"这个接口，但是引擎发现值与原来相同，不更新，直接返回；

3. 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因为是一致性读所以匹配不上。