一文带你了解MySQL之事件隔离级别和MVCC

一、数据准备

为了我们学习的顺利举行，我们这边创建一张 hero表

1. CREATE TABLE hero(
2.         number INT PRIMARY KEY,
3.         name VARCHAR(4),
4.         country VARCHAR(2)
5. );

复制代码

这里需要留意的是，我们的 hero表的主键是number，而不是id，重要是后边要用到的事件id做一下区别，然后我们给这个表里插入一条数据

1. mysql> INSERT INTO hero VALUES(1,'张角','东汉');
2. Query OK, 1 row affected (0.01 sec

复制代码

如今我们表里的数据就是这样：

1. mysql> SELECT * FROM hero;
2. +--------+--------+---------+
3. | number | name   | country |
4. +--------+--------+---------+
5. |      1 | 张角   | 东汉    |
6. +--------+--------+---------+
7. 1 row in set (0.00 sec)

复制代码

二、事件隔离级别

我们知道MySQL是CS架构的软件，多少个客户端与服务器毗连上之后，就可以称之为一个会话（Session）。每个客户端都可以在自己的会话中向服务器发出请求语句，一个请求语句大概是某个事件的一部分，也就是对于服务器来说大概同时处理多个事件。在事件简介的章节中我们说过事件有一个称之为隔离性的特性，理论上在某个事件对某个数据举行访问时，其他事件应该举行排队，当该事件提交之后，其他事件才可以继续访问这个数据。但是这样子的话对性能影响太大，我们既想保持事件的隔离性，又想让服务器在处理访问同一数据的多个事件时性能尽量高些，鱼和熊掌不可得兼，舍一部分隔离性而取性能者也。
2.1 事件并发执行遇到的题目

怎么个舍弃法呢？我们先得看一下访问雷同数据的事件在不包管串行执行（也就是执行完一个再执行另一个）的环境下大概会出现哪些题目：
脏写（Dirty Write）： 假如一个事件修改了另一个未提交事件修改过的数据，那就意味着发生了脏写，示意图如下：
Session ASession B1BEGIN;2BEGIN;3UPDATE hero SET name = ‘赵云’ WHERE number = 1;4UPDATE hero SET name = ‘法正’ WHERE number = 1;5COMMIT;6ROLLBACK; 如上表，Session A和Session B各开启了一个事件，Session B中的事件先将number列为1的记录的name列更新为'赵云'，然后Session A中的事件接着又把这条number列为1的记录的name列更新为法正。假如之后Session B中的事件举行了回滚，那么Session A中的更新也将不复存在，这种现象就称之为脏写。这时Session A中的事件就很懵逼，我明显把数据更新了，末了也提交事件了，怎么到末了说自己啥也没干呢？
脏读（Dirty Read） ：假如一个事件读到了另一个未提交事件修改过的数据，那就意味着发生了脏读，示意图如下：
Session ASession B1BEGIN;2BEGIN;3UPDATE hero SET name = ‘赵云’ WHERE number = 1;4SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘赵云’，味的发生了脏读)5COMMIT;6ROLLBACK; 如上表，Session A和Session B各开启了一个事件，Session B中的事件先将number列为1的记录的name列更新为'赵云'，然后Session A中的事件再去查询这条number为1的记录，假如读到列name的值为'赵云'，而Session B中的事件稍后举行了回滚，那么Session A中的事件相当于读到了一个不存在的数据，这种现象就称之为脏读。
不可重复读（Non-Repeatable Read）： 假如一个事件只能读到另一个已经提交的事件修改过的数据，而且其他事件每对该数据举行一次修改并提交后，该事件都能查询得到最新值，那就意味着发生了不可重复读，示意图如下：
Session ASession B1BEGIN;2SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘张角’)3UPDATE hero SET name = ‘赵云’ WHERE number = 1;4SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘赵云’，意味的发生了不可重复读)5UPDATE hero SET name = ‘法正’ WHERE number = 1;6SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘法正’，意味的发生了不可重复读) 如上表，我们在Session B中提交了几个隐式事件（意味着语句竣事事件就提交了），这些事件都修改了number列为1的记录的列name的值，每次事件提交之后，假如Session A中的事件都可以查看到最新的值，这种现象也被称之为不可重复读。
幻读（Phantom）： 假如一个事件先根据某些条件查询出一些记录，之后另一个事件又向表中插入了符合这些条件的记录，原先的事件再次按照该条件查询时，能把另一个事件插入的记录也读出来，那就意味着发生了幻读，示意图如下：
Session ASession B1BEGIN;2SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘张角’)3INSERT INTO hero VALUES(1,‘许诸’,‘魏国’);4SELECT * FROM hero WHERE number = 1;(此时读到的name列的值为‘张角’、‘许诸’，意味的发生了幻读) 如上表，Session A中的事件先根据条件number > 0这个条件查询表hero，得到了name列值为'张角'的记录；之后Session B中提交了一个隐式事件，该事件向表hero中插入了一条新记录；之后Session A中的事件再根据雷同的条件number > 0查询表hero，得到的效果集中包含Session B中的事件新插入的那条记录，这种现象也被称之为幻读。
Q1: 假如Session B中是删除了一些符合number > 0的记录而不是插入新记录，那Session A中之后再根据number > 0的条件读取的记录变少了，这种现象算不算幻读呢？
W1: 明确说一下，这种现象不属于幻读，幻读强调的是一个事件按照某个雷同条件多次读取记录时，后读取时读到了之前没有读到的记录。
   小提士：
那对于先前已经读到的记录，之后又读取不到这种环境，算啥呢？其实这相当于对每一条记录都发生了不可重复读的现象。幻读只是重点强调了读取到了之前读取没有获取到的记录。
  2.2 SQL标准中的四种隔离级别

我们上边先容了几种并发事件执行过程中大概遇到的一些题目，这些题目也有轻重缓急之分，我们给这些题目按照严重性来排一下序：

1. 脏写 > 脏读 > 不可重复读 > 幻读

复制代码

我们上边所说的舍弃一部分隔离性来换取一部分性能在这里就体如今：设立一些隔离级别，隔离级别越低，越严重的题目就越大概发生。于是制定了一个所谓的SQL标准，在标准中设立了4个隔离级别：

• READ UNCOMMITTED：未提交读
  
• READ COMMITTED：已提交读
  
• REPEATABLE READ：可重复读
  
• SERIALIZABLE：可串行化
  

SQL标准中规定，针对不同的隔离级别，并发事件可以发生不同严重程度的题目，具体环境如下：
隔离级别脏读不可重复读幻读READ UNCOMMITTEDPossiblePossiblePossibleREAD COMMITTEDNot PossiblePossiblePossibleREPEATABLE READNot PossibleNot PossiblePossibleSERIALIZABLENot PossibleNot PossibleNot Possible 也就是说：

• READ UNCOMMITTED隔离级别下，大概发生脏读、不可重复读和幻读题目。
  
• READ COMMITTED隔离级别下，大概发生不可重复读和幻读题目，但是不可以发生脏读题目。
  
• REPEATABLE READ隔离级别下，大概发生幻读题目，但是不可以发生脏读和不可重复读的题目。
  
• SERIALIZABLE隔离级别下，各种题目都不可以发生。
  

Q2: 脏写是怎么回事儿？怎么里边都没写呢？
W2: 这是因为脏写这个题目太严重了，不论是哪种隔离级别，都不允许脏写的环境发生。
2.3 MySQL中支持的四种隔离级别

不同的数据库厂商对SQL标准中规定的四种隔离级别支持不一样，比方说Oracle就只支持READ COMMITTED和SERIALIZABLE隔离级别。MySQL虽然支持4种隔离级别，但与SQL标准中所规定的各级隔离级别允许发生的题目却有些收支，MySQL在REPEATABLE READ隔离级别下，是可以禁止幻读题目的发生的。
MySQL的默认隔离级别为REPEATABLE READ，我们可以手动修改一下事件的隔离级别。
怎样设置事件的隔离级别
我们可以通过下边的语句修改事件的隔离级别：

1. SET [GLOBAL|SESSION|PERSIST] TRANSACTION ISOLATION LEVEL level;

复制代码

此中的level可选值有4个：

1. level: {
2.      REPEATABLE READ
3.    | READ COMMITTED
4.    | READ UNCOMMITTED
5.    | SERIALIZABLE
6. }

复制代码

设置事件的隔离级别的语句中，在SET关键字后可以放置GLOBAL关键字、SESSION关键字、PERSIST关键字或者什么都不放，这样会对不同范围的事件产生不同的影响，具体如下：

• 利用GLOBAL关键字（在全局范围影响）：
  比如：
  SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE;
  则：
  
  
  
  • 只对执行完该语句之后产生的会话起作用。
    
  • 当前已经存在的会话无效
    
  • 重启之后会恢复到默认值
    
  
  
• 利用SESSION关键字（在会话范围影响）：
  比如：
  SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
  则：
  
  
  
  • 对当前会话的所有后续的事件有效
    
  • 该语句可以在已经开启的事件中间执行，但不会影响当前正在执行的事件
    
  • 假如在事件之间执行，则对后续的事件有效
    
  • 重启之后会恢复到默认值
    
  
  
• 利用PERSIST关键字（使全局体系变量变为永久性）：
  比如：
  SET PERSIST TRANSACTION ISOLATION LEVEL SERIALIZABLE;
  则：
  
  
  
  • 只对执行完该语句之后产生的会话起作用
    
  • 当前已经存在的会话无效
    
  • 重启之后不会恢复到默认值
    
         小提示：
  在5.7版本以前在修改全局变量时候，并不会影响到设置文件，重启之后就会恢复到默认值，MySQL8可以利用PERSIST使全局体系变量变为永久性
     
  
• 上述三个关键字都不消（只对执行语句后的下一个事件产生影响）：
  比如：SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
  则：
  
  
  
  • 只对当前会话中下一个即将开启的事件有效。
    
  • 下一个事件执行完后，后续事件将恢复到之前的隔离级别。
    
  • 该语句不能在已经开启的事件中间执行，会报错的
    
  
  

想要查看当前会话默认的隔离级别可以通过查看体系变量transaction_isolation的值来确定：

1. mysql> SHOW VARIABLES LIKE 'transaction_isolation';
2. +-----------------------+--------------+
3. | Variable_name         | Value        |
4. +-----------------------+--------------+
5. | transaction_isolation | SERIALIZABLE |
6. +-----------------------+--------------+
7. 1 row in set (0.01 sec)

复制代码

或者利用更轻便的写法：

1. mysql> SELECT @@transaction_isolation;
2. +-------------------------+
3. | @@transaction_isolation |
4. +-------------------------+
5. | SERIALIZABLE            |
6. +-------------------------+
7. 1 row in set (0.00 sec)

复制代码

三、MVCC

3.1 版本链

我们前边说过，对于利用InnoDB存储引擎的表来说，它的聚簇索引记录中都包含两个须要的隐藏列（row_id并不是须要的，我们创建的表中有主键或者非NULL的UNIQUE键时都不会包含row_id列）：

• trx_id：每次一个事件对某条聚簇索引记录举行改动时，都会把该事件的事件id赋值给trx_id隐藏列。
  
• roll_pointer：每次对某条聚簇索引记录举行改动时，都会把旧的版本写入到undo日记中，然后这个隐藏列就相当于一个指针，可以通过它来找到该记录修改前的信息
  

比如我们的表hero如今只包含一条记录：

1. mysql> SELECT * FROM hero;
2. +--------+--------+---------+
3. | number | name   | country |
4. +--------+--------+---------+
5. |      1 | 张角   | 东汉    |
6. +--------+--------+---------+
7. 1 row in set (0.00 sec)

复制代码

假设插入该记录的事件id为80，那么此刻该条记录的示意图如下所示：

   小提示：
实际上insert undo只在事件回滚时起作用，当事件提交后，该类型的undo日记就没用了，它占用的Undo Log Segment也会被体系采取（也就是该undo日记占用的Undo页面链表要么被重用，要么被释放）。虽然真正的insert undo日记占用的存储空间被释放了，但是roll_pointer的值并不会被清除，roll_pointer属性占用7个字节，第一个比特位就标记着它指向的undo日记的类型，假如该比特位的值为1时，就代表着它指向的undo日记类型为insert undo。所以我们之后在画图时都会把insert undo给去掉，各人留意一下就好了。
  假设之后两个事件id分别为100、200的事件对这条记录举行UPDATE操作，操作流程如下：
trx 100trx 2001BEGIN;2BEGIN;3UPDATE hero SET name = ‘赵云’ WHERE number = 1;4UPDATE hero SET name = ‘法正’ WHERE number = 1;5COMMIT;6UPDATE hero SET name = ‘孙尚香’ WHERE number = 1;7UPDATE hero SET name = ‘妲己’ WHERE number = 1;8COMMIT;   小提示：
能不能在两个事件中交织更新同一条记录呢？哈哈，这不就是一个事件修改了另一个未提交事件修改过的数据，沦为了脏写了么？InnoDB利用锁来包管不会有脏写环境的发生，也就是在第一个事件更新了某条记录后，就会给这条记录加锁，另一个事件再次更新时就需要等待第一个事件提交了，把锁释放之后才可以继续更新。关于锁的更多细节我们后续的文章中再举行学习～
  每次对记录举行更新，都会记录一条undo日记，每条undo日记也都有一个roll_pointer属性（INSERT操尴尬刁难应的undo日记没有该属性，因为该记录并没有更早的版本），可以将这些undo日记都连起来，串成一个链表，所以如今的环境就像下图一样：

对该记录每次更新后，都会将旧值放到一条undo日记中，就算是该记录的一个旧版本，随着更新次数的增多，所有的版本都会被roll_pointer属性毗连成一个链表，我们把这个链表称之为版本链，版本链的头节点就是当前记录最新的值。另外，每个版本中还包含生成该版本时对应的事件id，这个信息很重要，我们稍后就会用到。
3.2 ReadView

对于利用READ UNCOMMITTED隔离级别的事件来说，由于可以读到未提交事件修改过的记录，所以直接读取记录的最新版本就好了；对于利用SERIALIZABLE隔离级别的事件来说，InnoDB的规定利用加锁的方式来访问记录（加锁是啥我们后续文章中说哈）；对于利用READ COMMITTED和REPEATABLE READ隔离级别的事件来说，都必须包管读到已经提交了的事件修改过的记录，也就是说假如另一个事件已经修改了记录但是尚未提交，是不能直接读取最新版本的记录的，核心题目就是：需要判断一下版本链中的哪个版本是当前事件可见的。为此，InnoDB提出了一个ReadView的概念，这个ReadView中重要包含4个比较重要的内容：

• m_ids：表示在生成ReadView时当前体系中活跃的读写事件的事件id列表。
  
• min_trx_id：表示在生成ReadView时当前体系中活跃的读写事件中最小的事件id，也就是m_ids中的最小值。
  
• max_trx_id：表示生成ReadView时体系中应该分配给下一个事件的id值。
         小提示：
  留意max_trx_id并不是m_ids中的最大值，事件id是递增分配的。比方说如今有id为1，2，3这三个事件，之后id为3的事件提交了。那么一个新的读事件在生成ReadView时，m_ids就包罗1和2，min_trx_id的值就是1，max_trx_id的值就是4。
  
• creator_trx_id：表示生成该ReadView的事件的事件id。
         小提示：
  我们前边说过，只有在对表中的记录做改动时（执行INSERT、DELETE、UPDATE这些语句时）才会为事件分配事件id，否则在一个只读事件中的事件id值都默认为0。
  

有了这个ReadView，这样在访问某条记录时，只需要按照下边的步骤判断记录的某个版本是否可见：

• 假如被访问版本的trx_id属性值与ReadView中的creator_trx_id值雷同，意味着当前事件在访问它自己修改过的记录，所以该版本可以被当前事件访问。
  
• 假如被访问版本的trx_id属性值小于ReadView中的min_trx_id值，表明生成该版本的事件在当前事件生成ReadView前已经提交，所以该版本可以被当前事件访问。
  
• 假如被访问版本的trx_id属性值大于或即是ReadView中的max_trx_id值，表明生成该版本的事件在当前事件生成ReadView后才开启，所以该版本不可以被当前事件访问。
  
• 假如被访问版本的trx_id属性值在ReadView的min_trx_id和max_trx_id之间，那就需要判断一下trx_id属性值是不是在m_ids列表中，假如在，阐明创建ReadView时生成该版本的事件还是活跃的，该版本不可以被访问；假如不在，阐明创建ReadView时生成该版本的事件已经被提交，该版本可以被访问。
  

假如某个版本的数据对当前事件不可见的话，那就顺着版本链找到下一个版本的数据，继续按照上边的步骤判断可见性，依此类推，直到版本链中的末了一个版本。假如末了一个版本也不可见的话，那么就意味着该条记录对该事件完全不可见，查询效果就不包含该记录。
在MySQL中，READ COMMITTED和REPEATABLE READ隔离级别的的一个非常大的区别就是它们生成ReadView的机遇不同。我们还是以表hero为例来，假设如今表hero中只有一条由事件id为80的事件插入的一条记录：

1. mysql> SELECT * FROM hero;
2. +--------+--------+---------+
3. | number | name   | country |
4. +--------+--------+---------+
5. |      1 | 张角   | 东汉    |
6. +--------+--------+---------+
7. 1 row in set (0.00 sec)

复制代码

接下来看一下READ COMMITTED和REPEATABLE READ所谓的生成ReadView的机遇不同到底不同在哪里
3.2.1 READ COMMITTED

对于利用REPEATABLE COMMITTED隔离级别的事件来说，每次读取数据前都生成一个ReadView。比方说如今体系里有两个事件id分别为100、200的事件在执行：

1. # Transaction 100
2. BEGIN;
3. UPDATE hero SET name = '赵云' WHERE number = 1;
4. UPDATE hero SET name = '法正' WHERE number = 1;

复制代码

1. # Transaction 200
2. BEGIN;
3. # 更新了一些别的表的记录
4. ...

复制代码

  小提示：
再次强调一遍，事件执行过程中，只有在第一次真正修改记录时（比如利用INSERT、DELETE、UPDATE语句），才会被分配一个单独的事件id，这个事件id是递增的。所以我们才在Transaction 200中更新一些别的表的记录，目的是让它分配事件id。
  此刻，表hero中number为1的记录得到的版本链表如下所示：

假设如今有一个利用READ COMMITTED隔离级别的事件开始执行：

1. # 使用READ COMMITTED隔离级别的事务
2. BEGIN;
3. # SELECT1：Transaction 100、200未提交
4. SELECT * FROM hero WHERE number = 1; # 得到的列name的值为'张角'

复制代码

这个SELECT1的执行过程如下：

• 在执行SELECT语句时会先生成一个ReadView，ReadView的m_ids列表的内容就是[100, 200]，min_trx_id为100，max_trx_id为201，creator_trx_id为0。
  
• 然后从版本链中挑选可见的记录，从图中可以看出，最新版本的列name的内容是'法正'，该版本的trx_id值为100，在m_ids列表内，所以不符合可见性要求，根据roll_pointer跳到下一个版本。
  
• 下一个版本的列name的内容是'赵云'，该版本的trx_id值也为100，也在m_ids列表内，所以也不符合要求，继续跳到下一个版本。
  下一个版本的列name的内容是'张角'，该版本的trx_id值为80，小于ReadView中的min_trx_id值100，所以这个版本是符合要求的，末了返回给用户的版本就是这条列name为'张角'的记录。
  

1. # Transaction 100
2. BEGIN;
3. UPDATE hero SET name = '赵云' WHERE number = 1;
4. UPDATE hero SET name = '法正' WHERE number = 1;
5. COMMIT;

复制代码

然后再到事件id为200的事件中更新一下表hero中number为1的记录：

1. # Transaction 200
2. BEGIN;
3. # 更新了一些别的表的记录
4. UPDATE hero SET name = '孙尚香' WHERE number = 1;
5. UPDATE hero SET name = '妲己' WHERE number = 1;

复制代码

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

然后再到刚才利用READ COMMITTED隔离级别的事件中继续查找这个number为1的记录，如下：

1. # 使用READ COMMITTED隔离级别的事务
2. BEGIN;
4. # SELECT1：Transaction 100、200均未提交
5. SELECT * FROM hero WHERE number = 1; # 得到的列name的值为'张角'
7. # SELECT2：Transaction 100提交，Transaction 200未提交
8. SELECT * FROM hero WHERE number = 1; # 得到的列name的值为'法正'

复制代码

这个SELECT2的执行过程如下：

• 在执行SELECT语句时会又会单独生成一个ReadView，该ReadView的m_ids列表的内容就是[200]（事件id为100的那个事件已经提交了，所以再次生成快照时就没有它了），min_trx_id为200，max_trx_id为201，creator_trx_id为0。
  
• 然后从版本链中挑选可见的记录，从图中可以看出，最新版本的列name的内容是'妲己'，该版本的trx_id值为200，在m_ids列表内，所以不符合可见性要求，根据roll_pointer跳到下一个版本。
  
• 下一个版本的列name的内容是'孙尚香'，该版本的trx_id值为200，也在m_ids列表内，所以也不符合要求，继续跳到下一个版本。
  
• 下一个版本的列name的内容是'法正'，该版本的trx_id值为100，小于ReadView中的min_trx_id值200，所以这个版本是符合要求的，末了返回给用户的版本就是这条列name为'法正'的记录。
  

以此类推，假如之后事件id为200的记录也提交了，再次在利用READ COMMITTED隔离级别的事件中查询表hero中number值为1的记录时，得到的效果就是'妲己'了，具体流程我们就不分析了。总结一下就是：利用READ COMMITTED隔离级别的事件在每次查询开始时都会生成一个独立的ReadView。
3.2.2 REPEATABLE READ

对于利用REPEATABLE READ隔离级别的事件来说，只会在第一次执行查询语句时生成一个ReadView，之后的查询就不会重复生成了。比方说如今体系里有两个事件id分别为100、200的事件在执行：

1. # Transaction 100
2. BEGIN;
3. UPDATE hero SET name = '赵云' WHERE number = 1;
4. UPDATE hero SET name = '法正' WHERE number = 1;

复制代码

1. # Transaction 200
2. BEGIN;
3. # 更新了一些别的表的记录
4. ...

复制代码

此刻，表hero中number为1的记录得到的版本链表如下所示：

假设如今有一个利用REPEATABLE READ隔离级别的事件开始执行：

1. # 使用REPEATABLE READ隔离级别的事务
2. BEGIN;
3. # SELECT1：Transaction 100、200未提交
4. SELECT * FROM hero WHERE number = 1; # 得到的列name的值为'张角'

复制代码

这个SELECT1的执行过程如下：

• 在执行SELECT语句时会先生成一个ReadView，ReadView的m_ids列表的内容就是[100, 200]，min_trx_id为100，max_trx_id为201，creator_trx_id为0。
  
• 然后从版本链中挑选可见的记录，从图中可以看出，最新版本的列name的内容是'法正'，该版本的trx_id值为100，在m_ids列表内，所以不符合可见性要求，根据roll_pointer跳到下一个版本。
  
• 下一个版本的列name的内容是'赵云'，该版本的trx_id值也为100，也在m_ids列表内，所以也不符合要求，继续跳到下一个版本。
  
• 下一个版本的列name的内容是'张角'，该版本的trx_id值为80，小于ReadView中的min_trx_id值100，所以这个版本是符合要求的，末了返回给用户的版本就是这条列name为'张角'的记录。
  

之后，我们把事件id为100的事件提交一下：

1. # Transaction 100
2. BEGIN;
3. UPDATE hero SET name = '关羽' WHERE number = 1;
4. UPDATE hero SET name = '张飞' WHERE number = 1;
5. COMMIT;

复制代码

然后再到事件id为200的事件中更新一下表hero中number为1的记录：

1. # Transaction 200
2. BEGIN;
3. # 更新了一些别的表的记录
4. ...
5. UPDATE hero SET name = '孙尚香' WHERE number = 1;UPDATE hero SET name = '妲己' WHERE number = 1;

复制代码

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

然后再到刚才利用REPEATABLE READ隔离级别的事件中继续查找这个number为1的记录，如下：

1. # 使用REPEATABLE READ隔离级别的事务
2. BEGIN;
4. # SELECT1：Transaction 100、200均未提交
5. SELECT * FROM hero WHERE number = 1; # 得到的列name的值为'张角'
7. # SELECT2：Transaction 100提交，Transaction 200未提交
8. SELECT * FROM hero WHERE number = 1; # 得到的列name的值仍为'张角'

复制代码

这个SELECT2的执行过程如下：

• 因为当前事件的隔离级别为REPEATABLE READ，而之前在执行SELECT1时已经生成过ReadView了，所以此时直接复用之前的ReadView，之前的ReadView的m_ids列表的内容就是[100, 200]，min_trx_id为100，max_trx_id为201，creator_trx_id为0
  
• 然后从版本链中挑选可见的记录，从图中可以看出，最新版本的列name的内容是'妲己'，该版本的trx_id值为200，在m_ids列表内，所以不符合可见性要求，根据roll_pointer跳到下一个版本。
  
• 下一个版本的列name的内容是'孙尚香'，该版本的trx_id值为200，也在m_ids列表内，所以也不符合要求，继续跳到下一个版本。
  下一个版本的列name的内容是'法正'，该版本的trx_id值为100，而m_ids列表中是包含值为100的事件id的，所以该版本也不符合要求，同理下一个列name的内容是'赵云'的版本也不符合要求。继续跳到下一个版本。
  
• 下一个版本的列name的内容是'张角'，该版本的trx_id值为80，小于ReadView中的min_trx_id值100，所以这个版本是符合要求的，末了返回给用户的版本就是这条列‘name’为'张角'的记录。
  

也就是说两次SELECT查询得到的效果是重复的，记录的列name值都是'张角'，这就是可重复读的寄义。假如我们之后再把事件id为200的记录提交了，然后再到刚才利用REPEATABLE READ隔离级别的事件中继续查找这个number为1的记录，得到的效果还是'张角'，具体执行过程各人可以自己分析一下。
3.3 MVCC小结

从上边的形貌中我们可以看出来，所谓的MVCC（Multi-Version Concurrency Control ，多版本并发控制）指的就是在利用READ COMMITTD、REPEATABLE READ这两种隔离级别的事件在执行普通的SELECT操作时访问记录的版本链的过程，这样子可以使不同事件的读-写、写-读操作并发执行，从而提升体系性能。READ COMMITTD、REPEATABLE READ这两个隔离级别的一个很大不同就是：生成ReadView的机遇不同，READ COMMITTD在每一次举行普通SELECT操作前都会生成一个ReadView，而REPEATABLE READ只在第一次举行普通SELECT操作前生成一个ReadView，之后的查询操作都重复利用这个ReadView就好了。
   小提示：
我们之前说执行DELETE语句或者更新主键的UPDATE语句并不会立即把对应的记录完全从页面中删除，而是执行一个所谓的delete mark操作，相当于只是对记录打上了一个删除标志位，这重要就是为MVCC服务的，各人可以对比上边举的例子自己试想一下怎么利用。
另外，所谓的MVCC只是在我们举行普通的SEELCT查询时才生效，制止到目前我们所见的所有SELECT语句都算是普通的查询，至于啥是个不普通的查询，我们稍后再说哈～
  四、关于purge

各人有没有发现两件事儿：

• 我们说insert undo在事件提交之后就可以被释放掉了，而update undo由于还需要支持MVCC，不能立即删撤消。
  我们在学习undo日记的时候，一个事件写的一组undo日记中都有一个Undo Log Header部分，这个Undo Log Header中有一个名为TRX_UNDO_HISTORY_NODE的属性，表示名为History链表的节点。当一个事件提交之后，就会把这个事件的执行过程产生的这一组Update undo日记插入到History链表的头部
  我们还说过，每个回滚段都对应一个名为Rollbcak Segment Header的页面，这个页面中有两个属性：
  
  
  
  • TRX_RSEG_HISTORY：表示Histroy链表的基节点
    
  • TRX_RSEG_HISTORY_SIZE：表示Histroy链表占用的页面数目
    
  也就是说每个回滚段都有一个History链表，一个事件在某个回滚段中写入的一组update undo日记在该事物提交之后就会参加这个回滚段的History链表。体系中存在很多回滚段，这也意味着大概存在很多个History链表。不过参加到History链表的update undo日记所占用的存储空间页没有释放掉，他们总不能一直存在吧，那得用多大的存储空间存放这些undo日记。
  
  
• 为了支持MVCC，对于delete mark操作来说，仅仅是在记录上打一个删除标记，并没有真正将它删撤消。
  各人应该还记得，在一组undo日记中的Undo Log Header部分有个名为TRX_UNDO_DEL_MARKS的属性，用来标记本组的undo日记中是否包含因delete mark操作二产生的日记，这些打了删除标记的记录也不能一直存在吧？
  

为了节省空间，我们应该在合适的时候把update undo日记以及仅仅被标记为删除的记录彻底删除，这个删除操作就是purge。不过于题目的关健在于这个合适的时候到底是什么时候？
update undo日记和被标记删除的记录都是为了支持MVCC而存在的，只要体系中最早产生的ReadView不在访问它们，它们的任务就此竣事了，就可以丢进历史的垃圾堆里了。一个ReadView在什么时候才肯定不会访问某个事物执行过程中产生的undo日记呢？其实，只要我们能包管生成ReadView时，某个事物已经提交，那么该ReadView肯定就不需要访问事物运行过程中产生的undo日记了（因为该事物所改动的最新版均对该ReadView可见）。
InnoDB为此做了两件事：

• 在一个事件提交时，会为这个事件生成一个名为事件no的值，该值用来表示事件提交的顺序。先提交的事件的事件no值小，后提交的事件的事件no值大。
  别忘看在一组undo日记中对应的Undo Log Header部分有一个名为TRX_UNDO_TRX_NO的属性。当事件提交时，就把该事物对应的事件no值填到这个属性中，因为事件no代表着各个事件提交的顺序，而History链表又是按照事件提交的顺序来排列各种undo日记，所以History链表中各组的undo日记也是按照对应的事件no来排序的。
  
• 一个ReadView结构除了包含前面学习的几个属性之外，还会包含一个事件no的属性。在生成一个ReadView时，会把比当前体系中最大的事件no的值还大1的值赋予这个属性。
  

InnoDB还把当前体系中所有的ReadView按照创建时间连成了一个链表。当执行purge操作时（这个purge操作是在专门的后线程中执行的），就把体系中最早生成的ReadView给取出来。假如当前体系中不存在ReadView,那就现场创建一个（新创建的这个ReadView的事件no值肯定比当前已经提交的事件的事件no值大）。然后从各个回滚段的History链表中取出事件no值较小的各组undo日记。假如第一组undo日记的事件no小于当前体系最早生成的ReadView的事件no，就意味着该组undo日记没有用了，就会从History链表中移除，而且释放掉它们占用的存储空间。假如该组undo日记包含因delete mark操作而产生的undo日记（TRX_UNDO_DEL_MARKS的属性值为1），那么也需要将对应的标记为删除的记录给彻底删除。
这里我们需要留意的一点，当前体系中体系最早生成的ReadView决定了purge操作中可以清算哪些update undo日记以及打了删除标记的记录。假如某个事物利用的REPEATABLE READ隔离级别，那么该事物一直复用最初产生的ReadView。假如这个事件运行了很久，一直没有提交，那么最早产生的ReadView会一直不释放。体系中updtae undo日记和打了删除标记的记录就会越来越多，表空间对应的文件也会越来越大，一条记录的版本链将越来越长，从而影响体系的性能。
五、总结

• 并发的事件在运行过程中会出现一些大概引发一致性题目的现象，具体如下:
  
  
  
  • 脏写：一个事件修改了另一个未提交事件修改过的数据
    
  • 脏读：一个事件读到了另一个未提交事件修改过的数据
    
  • 不可重复读：一个事件修改了另一个未提交事件读取的数据
    
  • 幻读：一个事件先根据某些搜索条件查询出一些记录，在该事件未提交时，另一个事件写入了一些符合那些搜索条件的记录
    
  
  
• SOL标准中的4种隔离级别：
  
  
  
  • READ UNCOMMITTED：大概发生脏读、不可重复读和幻读现象
    
  • READCOMMITTED：大概发生不可重复读和幻读现象，但是不大概发生脏读现象。
    
  • REPEATABLE READ：大概发生幻读现象，但是不大概发生脏读和不可重复读的现象
    
  • SERIALIZABLE：各种现象都不可以发生。
    
  实际上，MySOL在REPEATABLE READ隔离级别下是可以在很大程度上禁止出现幻读现象的。
  
  
• 下面的语句用来设置事件的隔离级别:
  SET [GLOBALI|SESSION|PERSIST] TRANSACTION ISOLATION LEVEL Level;
  
• 聚簇索引记录和undo日记中的roll pointer属性可以串连成一个记录的版本链
  
• 通过生成ReadView来判断记录的某个版本的可见性，此中READ COMMITTD在每一次举行普通SELECT操作前都会生成一个ReadView，而REPEATABLE READ只在第一次举行普通SELECT操作前生成一个ReadView，之后的查询操作都重复利用这个ReadView
  
• 当前体系中，假如最早生成的 ReadView 不再访问undo日记以及打了删除标记的记录则可以通过purge操作将它们清除。
  

至此今天的学习就到此竣事了，愿您成为坚如盘石的自己~~~
​
   You can’t connect the dots looking forward; you can only connect them looking backwards. So you have to trust that the dots will somehow connect in your future.You have to trust in something - your gut, destiny, life, karma, whatever. This approach has never let me down, and it has made all the difference in my life
  假如我的内容对你有帮助，请 点赞、批评、收藏，创作不易，各人的支持就是我坚持下去的动力！
本文章参考：小孩子《MySQL是怎样运行的》

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。