mysql重复读怎么实现 mysql重复读是什么

mysql是如何实现可重复读的？

一个事务要更新一行，如果刚好有另外一个事务拥有这一行的行锁，会被锁住，进入等待状态。既然进入了等待状态，那么等到这个事务自己获取到行锁要更新数据的时候，它读到的值又是什么呢?

可重复读隔离级别下，事务在启动的时候就“拍了个整个库的快照”。如果一个库有100G，那么我启动一个事务，MySQL就要拷⻉100G的数据出来，这个过程得多慢啊。但是平时事务执行起来却是非常快的。不是全部拷贝出来那是怎么实现的呢?

InnoDB里面每个事务有一个唯一的事务ID，叫作transaction id。它是在事务开始的时候向InnoDB的事务系统申请的，是按申请顺序严格递增的。

而每行数据也都是有多个版本的。每次事务更新数据的时候，都会生成一个新的数据版本，并且把transaction id赋值给这个数 据版本的事务ID，记为row trx_id。同时，旧的数据版本要保留，并且在新的数据版本中，能够有信息可以直接拿到它。

数据表中的一行记录，其实可能有多个版本(row)，每个版本有自己的row trx_id。

图中虚线框里是同一行数据的4个版本，当前最新版本是V4，k的值是22，它是被transaction id 为25的事务更新的，因此它的row trx_id也是25。语句更新会生成undo log(回滚日志)，图中的三个虚线箭头，就是undo log。

按照可重复读的定义，一个事务启动的时候，能够看到所有已经提交的事务结果。但是之后，这个事务执行期间，其他事务的更新对它不可⻅。

一个事务只需要在启动的时候声明说，“以我启动的时刻为准，如果一个数据版本是在我启动之前生成的，就认;如果是我启动以后才生成的，我就不认，我必须要找到它的上一个版本”。

如果“上一个版本”也不可⻅，那就得继续往前找。如果是这个事务自己更新的数据，它自己还是要认的。

在实现上， InnoDB为每个事务构造了一个数组，用来保存这个事务启动瞬间，当前正在“活跃”的所有事务ID。“活跃”指的就 是，启动了但还没提交。数组里面事务ID的最小值记为低水位，当前系统里面已经创建过的事务ID的最大值加1记为高水位。 这个视图数组和高水位，就组成了当前事务的一致性视图(read-view)。而数据版本的可⻅性规则，就是基于数据的row trx_id和这个一致性视图的对比结果得到的。

InnoDB利用了“所有数据都有多个版本”的这个特性，实现了“秒级创建快照”的能力。

回到我们最开始的表格，看看最后执行的结果是多少。做如下假设:

事务A的视图数组就是[99,100], 事务B的视图数组是[99,100,101], 事务C的视图数组是[99,100,101,102]。为了简化分析，我先把其他干扰语句去掉，只画出跟事务A查询逻辑有关的操作:

第一个有效更新是事务C，把数据从(1,1)改成了(1,2)。这时候，这个数据的最新版本的row trx_id是102，而90这个版本已经成为了历史版本。 第二个有效更新是事务B，把数据从(1,2)改成了(1,3)。这时候，这个数据的最新版本(即row trx_id)是101，而102又成为了历史版本。

事务B的update语句，如果按照一致性读，好像结果不对哦?

事务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。

select语句如果加锁，也是当前读。

如果把事务A的查询语句select * from t where id=1修改一下，加上lock in share mode 或 for update，也都可以读到版本号是101的数据，返回的k的值是3。下面这两个select语句，就是分别加了读锁(S锁，共享锁)和写锁(X锁，排他锁)。

事务C’的不同是，更新后并没有⻢上提交，在它提交前，事务B的更新语句先发起了。前面说过了，虽然事务C’还没提交，但是(1,2)这个版本也已经生成了，并且是当前的最新版本。那么，事务B的更新语句会怎么处理呢?

两阶段锁协议，事务C’没提交，也就是说(1,2)这个版本上的写锁还没释放。 而事务B是当前读，必须要读最新版本，而且必须加锁，因此就被锁住了，必须等到事务C’释放这个锁，才能继续它的当前读。

回到最初的问题，事务的可重复读的能力是怎么实现的?

相关问答

Q1: mysql 解决可提交读、可重复读、幻读

这张图本人觉得总结得挺好的，在一般的互联网项目中，基本上用的都是Innodb引擎，一般只涉及到的都是行级锁，但是如果sql语句中不带索引进行操作，可能会导致锁表，这是不推荐的，性能非常低，可能会导致全表扫描等，行锁的具体实现算法有以下几种mysql特有的锁：

Record Lock(记录锁):单个行记录的锁,一般是唯一索引或者主键上的加锁

Gap Lock(间隙锁):锁定一个区间，但是不包括自身，开区间的锁，RR级别才会有间隙锁，间隙锁的唯一目的是防止区间数据的插入，所以间隙锁与间隙锁之间是不会相互阻塞的

Next-key Lock(临键锁):与间隙锁的区别是包括自身，是左开右闭区间，RR级别才会有

加锁规则里面，包含了两个“原则”、两个“优化”和一个“bug”。

原则 1：加锁的基本单位是 next-key lock，希望你还记得，next-key lock 是前开后闭区间。

原则 2：查找过程中访问到的对象才会加锁。

优化 1：索引上的等值查询，给唯一索引加锁的时候，next-key lock 退化为行锁。

优化 2：索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock 退化为间隙锁。

一个 bug：唯一索引上的范围查询会访问到不满足条件的第一个值为止。

举例来说明上述的原则：

建表

插入数据：

INSERT INTO t ( id , c , d ) VALUES (0, 0, 0);

INSERT INTO t ( id , c , d ) VALUES (5, 5, 10);

INSERT INTO t ( id , c , d ) VALUES (10, 10, 10);

INSERT INTO t ( id , c , d ) VALUES (15, 15, 15);

INSERT INTO t ( id , c , d ) VALUES (20, 20, 20);

INSERT INTO t ( id , c , d ) VALUES (25, 25, 25);

例子1：锁表

因为d字段上没有建索引，所以涉及该字段的查询加锁会锁住整个表

因为d字段上面没有建立索引，所以事务1执行后会导致整个表被锁，后面所有的操作都会在等待整个表锁被释放

例子2：主键/唯一索引 记录锁

id字段为主键，而且事务1查询命中了唯一的记录，默认是加Next-key Lock，区间是（0，5]，但是根据优化1，唯一索引/主键上的等值查询，会退化为行锁，所以只会锁5这个记录。

例子3：主键/唯一索引上的间隙锁

由于表 t 中没有 id=7 的记录，所以用我们上面提到的加锁规则判断一下的话：根据原则 1，加锁单位是 next-key lock，事务1加锁范围就是 (5,10]；同时根据优化 2，这是一个等值查询 (id=7)，而 id=10 不满足查询条件，next-key lock 退化成间隙锁，因此最终加锁的范围是 (5,10)，所以事务2会阻塞，事务3执行成功。

例子4：普通索引上的间隙锁

c字段是普通索引，事务1执行时默认是对区间（0,5]加间隙锁，根据优化2，非唯一索引/主键会继续向右遍历，找到10，所以最终的加锁为（0，5]的Next-Key锁+(5，10)的间隙锁，所以事务2阻塞，事务3成功。

例子5：间隙锁与行锁

事务1默认的Next-Key锁区间是(0，5],根据优化2会向右遍历，找到不满足查询条件的10，退化成间隙锁，所以事务1的锁是（0，5]的Next-Key锁+(5，10)的间隙锁，这两个锁与行锁是冲突的，而事务2申请的Next-Key锁是和事务1一样，但是c=5的行锁与事务1冲突，所以产生了阻塞，如果改为update t set d=1000 where c=6;因为此时产生的间隙锁为（5，10），而间隙锁与间隙锁是不冲突的，不会产生阻塞

例子6：lock in share mode锁覆盖索引

事务1存在覆盖索引的情况，不会去回表，lock in share mode这种情况下只会锁c字段索引，而事务2是对主键加行锁，所以两者不存在冲突。

例子7：主键/唯一索引上的范围查询

开始执行的时候，要找到第一个 id=10 的行，因此本该是 Next-Key Lock(5,10]，根据优化 1， 主键 id 上的等值条件，退化成行锁，只加了 id=10 这一行的行锁。范围查找就往后继续找，找到 id=15 这一行停下来，因此需要加 Next-Key Lock(10,15]，所以事务3是冲突的。

例子8：普通索引上的范围查询

开始执行时，找到第一个满足条件的行10，加锁Next-Key Lock(5,10]，因为不是唯一索引，所以不会退化，继续向后面找，找到15这一行停下来，因此需要加 Next-Key Lock(10,15]，因为是范围查询，所以锁不会退化。

快照读： 通过MVCC实现，该技术不仅可以保证innodb的可重复读，而且可以防止幻读，但是他读取的数据虽然是一致的，但是数据是历史数据。

简单的select操作(不包括 select … lock in share mode, select … for update)

当前读： 要做到保证数据是一致的，同时读取的数据是最新的数据,innodb提供了next-key lock，即gap锁与行锁结合来实现。

select … lock in share mode

select … for update

insert

update

delete

自己理解：

简单的select是快照读，快照读实现可提交读，可重复读和幻读是通过MVCC+ReadView实现的,而当前读实现这几种是通过锁来实现的,为了说明具体原理,下面介绍下MVCC和ReadView概念，所以简单的select是通过乐观锁实现的，当前读是通过悲观锁实现的。

参考文章：

Q2: MySQL可重复读防止幻读

接上篇 事务隔离级别和幻读 ，留了个坑，没想到竟然过了10天，时间不注意真的过的好快。顺便提下，图片链接是属于网站的，开发自己的图床迫在眉睫，万一哪天迁移就要做很多额外工作，一些概念或者思路用图片表达更直观清楚。

回到正题，之前提到一般情况下MySQL的InnoDB引擎在可重复读的情况下是没法保证不出现幻读的，但实际情况是MySQL可以通过加锁来防止幻读的出现，这种锁定通过Next-key机制来实现，是属于记录锁和间隙锁(Gap锁)的结合。

引申，行级别锁的三种算法:

举个存在唯一索引和辅助索引的例子做说明：

执行 select * from test where b = 3 for update

存在两个索引，分别加锁，唯一主键列a加record lock ， 辅助索引列b加next-key lock (1,3) 以及给下一个值的区间(3,6)加gap锁；

因此在另一个事务里执行以下语句都会阻塞，具体分析：

第一个阻塞因为加了唯一索引的record lock a = 5；

第二个主键插入4，符合条件，但是根据辅助索引b 的范围, b = 2 在(1,3)中，同样阻塞；

第三个a =6 不在主键a锁定范围，b = 5 也不在辅助索引b 的范围(1,3)中，但在另一个gap锁范围(3,6)中，因此也阻塞；

这种锁定情形下，可以执行的包括类似语句：

insert的特殊情况

对于insert 会检查下一条记录是否被锁定，如上述例子有 select * from test where b = 3 for update 插入 insert into test select 2,2 会检测到b = 3 已经被锁定，而 insert into test select 2,0 可以执行；

[1]:《MySQL技术内幕：InnoDB存储引擎》-第六章：锁

Q3: mysql 可重复读如何实

SERIALIZABLE 采用两阶段锁来保证隔离性

加锁阶段：只加锁，不放锁

解锁阶段：只放锁，不加锁。

且无论 读 还是 写 ， 都要加锁

但是这样做了以后， 失去了MVCC的特性 （非锁定的一致性读）

Q4: 求数据库大神，mysql事务隔离级别repeatable-read 详解

术式之后皆为逻辑mysql重复读怎么实现，一切皆为需求和实现。希望此文能从需求、现状和解决方式mysql重复读怎么实现的角度帮大家理解隔离级别。

隔离级别的产生

在串型执行的条件下mysql重复读怎么实现，数据修改的顺序是固定的、可预期的结果，但是并发执行的情况下，数据的修改是不可预期的，也不固定，为了实现数据修改在并发执行的情况下得到一个固定、可预期的结果，由此产生了隔离级别。

所以隔离级别的作用是用来平衡数据库并发访问与数据一致性的方法。

事务的4种隔离级别

READ UNCOMMITTED       未提交读，可以读取未提交的数据。READ COMMITTED         已提交读，对于锁定读(select with for update 或者 for share)、update 和 delete 语句，                       InnoDB 仅锁定索引记录，而不锁定它们之间的间隙，因此允许在锁定的记录旁边自由插入新记录。                       Gap locking 仅用于外键约束检查和重复键检查。REPEATABLE READ        可重复读，事务中的一致性读取读取的是事务第一次读取所建立的快照。SERIALIZABLE           序列化

在了解了 4 种隔离级别的需求后，在采用锁控制隔离级别的基础上，mysql重复读怎么实现我们需要了解加锁的对象(数据本身间隙)，以及了解整个数据范围的全集组成。

数据范围全集组成

SQL 语句根据条件判断不需要扫描的数据范围（不加锁）；

SQL 语句根据条件扫描到的可能需要加锁的数据范围；

以单个数据范围为例，数据范围全集包含mysql重复读怎么实现：（数据范围不一定是连续的值，也可能是间隔的值组成）

1. 数据已经填充了整个数据范围：（被完全填充的数据范围，不存在数据间隙）

整形，对值具有唯一约束条件的数据范围 1～5 ，

已有数据1、2、3、4、5，此时数据范围已被完全填充；

整形，对值具有唯一约束条件的数据范围 1 和 5 ，

已有数据1、5，此时数据范围已被完全填充；

2. 数据填充了部分数据范围：（未被完全填充的数据范围，是存在数据间隙）

整形的数据范围 1～5 ，

已有数据 1、2、3、4、5，但是因为没有唯一约束，

所以数据范围可以继续被 1～5 的数据重复填充；

整形，具有唯一约束条件的数据范围 1～5 ，

已有数据 2，5，此时数据范围未被完全填充，还可以填充 1、3、4 ；

3. 数据范围内没有任何数据（存在间隙）

如下：

整形的数据范围 1～5 ，数据范围内当前没有任何数据。

在了解了数据全集的组成后，我们再来看看事务并发时，会带来的问题。

无控制的并发所带来的问题

并发事务如果不加以控制的话会带来一些问题，主要包括以下几种情况。

1. 范围内已有数据更改导致的：

更新丢失：当多个事务选择了同一行，然后基于最初选定的值更新该行时，

由于每个事物不知道其他事务的存在，最后的更新就会覆盖其他事务所做的更新；

脏读： 一个事务正在对一条记录做修改，这个事务完成并提交前，这条记录就处于不一致状态。

这时，另外一个事务也来读取同一条记录，如果不加控制，

第二个事务读取了这些“脏”数据，并据此做了进一步的处理，就会产生提交的数据依赖关系。

这种现象就叫“脏读”。

2. 范围内数据量发生了变化导致：

不可重复读：一个事务在读取某些数据后的某个时间，再次读取以前读过的数据，

却发现其读出的数据已经发生了改变，或者某些记录已经被删除了。

这种现象就叫“不可重复读”。

幻读：一个事务按相同的查询条件重新读取以前检索过的数据，

却发现其他事务插入了满足其查询条件的新数据，这种现象称为“幻读”。

可以简单的认为满足条件的数据量变化了。

因为无控制的并发会带来一系列的问题，这些问题会导致无法满足我们所需要的结果。因此我们需要控制并发，以实现我们所期望的结果(隔离级别)。

MySQL 隔离级别的实现

InnoDB 通过加锁的策略来支持这些隔离级别。

行锁包含：

Record Locks

索引记录锁，索引记录锁始终锁定索引记录，即使表中未定义索引，

这种情况下，InnoDB 创建一个隐藏的聚簇索引，并使用该索引进行记录锁定。

Gap Locks

间隙锁是索引记录之间的间隙上的锁，或者对第一条记录之前或者最后一条记录之后的锁。

间隙锁是性能和并发之间权衡的一部分。

对于无间隙的数据范围不需要间隙锁，因为没有间隙。

Next-Key Locks

索引记录上的记录锁和索引记录之前的 gap lock 的组合。

假设索引包含 10、11、13 和 20。

可能的next-key locks包括以下间隔，其中圆括号表示不包含间隔端点，方括号表示包含端点：

(负无穷大, 10]    (10, 11]    (11, 13]    (13, 20]    (20, 正无穷大)        对于最后一个间隔，next-key将会锁定索引中最大值的上方，

左右滑动进行查看

"上确界"伪记录的值高于索引中任何实际值。

上确界不是一个真正的索引记录，因此，实际上，这个 next-key 只锁定最大索引值之后的间隙。

基于此，当获取的数据范围中，数据已填充了所有的数据范围，那么此时是不存在间隙的，也就不需要 gap lock。

对于数据范围内存在间隙的，需要根据隔离级别确认是否对间隙加锁。

默认的 REPEATABLE READ 隔离级别，为了保证可重复读，除了对数据本身加锁以外，还需要对数据间隙加锁。

READ COMMITTED 已提交读，不匹配行的记录锁在 MySQL 评估了 where 条件后释放。

对于 update 语句，InnoDB 执行 "semi-consistent" 读取，这样它会将最新提交的版本返回到 MySQL，

以便 MySQL 可以确定该行是否与 update 的 where 条件相匹配。

总结延展：

唯一索引存在唯一约束，所以变更后的数据若违反了唯一约束的原则，则会失败。

当 where 条件使用二级索引筛选数据时，会对二级索引命中的条目和对应的聚簇索引都加锁；所以其他事务变更命中加锁的聚簇索引时，都会等待锁。

行锁的增加是一行一行增加的，所以可能导致并发情况下死锁的发生。

例如，

在 session A 对符合条件的某聚簇索引加锁时，可能 session B 已持有该聚簇索引的 Record Locks，而 session B 正在等待 session A 已持有的某聚簇索引的 Record Locks。

session A 和 session B 是通过两个不相干的二级索引定位到的聚簇索引。

session A 通过索引 idA，session B通过索引 idB 。

当 where 条件获取的数据无间隙时，无论隔离级别为 rc 或 rr，都不会存在间隙锁。

比如通过唯一索引获取到了已完全填充的数据范围，此时不需要间隙锁。

间隙锁的目的在于阻止数据插入间隙，所以无论是通过 insert 或 update 变更导致的间隙内数据的存在，都会被阻止。

rc 隔离级别模式下，查询和索引扫描将禁用 gap locking，此时 gap locking 仅用于外键约束检查和重复键检查（主要是唯一性检查）。

rr 模式下，为了防止幻读，会加上 Gap Locks。

事务中，SQL 开始则加锁，事务结束才释放锁。

就锁类型而言，应该有优化锁，锁升级等，例如rr模式未使用索引查询的情况下，是否可以直接升级为表锁。

就锁的应用场景而言，在回放场景中，如果确定事务可并发，则可以考虑不加锁，加快回放速度。

锁只是并发控制的一种粒度，只是一个很小的部分：

从不同场景下是否需要控制并发，(已知无交集且有序的数据的变更，MySQL 的 MTS 相同前置事务的多事务并发回放)

并发控制的粒度，(锁是一种逻辑粒度，可能还存在物理层和其他逻辑粒度或方式)

相同粒度下的优化，(锁本身存在优化，如IX、IS类型的优化锁)

粒度加载的安全性能(如获取行锁前，先获取页锁，页锁在执行获取行锁操作后即释放，无论是否获取成功)等多个层次去思考并发这玩意。

Q5: mysql可重复读的幻读解决方案

首先需要明确的就是“幻读”概念： 隔离级别是可重复读，在一个事务中前后两次查询，查到了其他事务insert进来的数据。

强调的是读取到了其他事务插入进来的数据。

下面来论证一下可重复读下幻读的解决方案

先明确一下，for update语法就是当前读，也就是查询当前已经提交的数据，并且是带悲观锁的。没有for update就是快照读，也就是根据readView读取的undolog中的数据。

如果按照以上猜想，那么整个执行结果就违背了 可重复读 的隔离级别了。

那么我们再假设select * from TABLE where d = 5 for update;这条语句锁定的是所有被扫描到的数据。

这是因为T2阶段的update会被阻塞住，毕竟所有被扫描到的记录都被锁定了。

按照上述推理过程，很显然，即使锁定所有扫描到的数据行，也依然存在幻读的情况。违背了 可重复读 的隔离级别。

针对这个情况，我们要解决幻读的问题，那么就要求针对所有被扫描的记录行以及还不存在的d=5的记录行都给锁住。

至此，当前查询结果完全满足 可重复读 的隔离级别。

通过以上推论，我们可以总结一下，在可重复读的隔离级别下，解决幻读除了需要锁定所有扫描到的记录行外，还需要锁定行之间的间隙，也就是通过间隙锁来解决幻读的问题。

关于mysql重复读怎么实现和mysql重复读是什么的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。