Next-Key Lock

概念

MySQL中，行锁有写锁X和读锁S两种，实际上行锁有3种实现算法，Next-Key Lock是其中之一。

1. Record Lock：字面意思，行记录的锁，实际上指的是对索引记录的锁定。
2. Gap Lock：也就是间隙锁，对索引项之间的间隙、对第一条记录前的间隙或最后一条记录后的间隙加锁，即锁定一个范围的记录，不会包含记录本身。间隙锁是可重复读RR隔离级别下特有的
3. Next-Key Lock：锁定一个范围的记录并包含记录本身。实际上就是相当于Record Lock+Gap Lock的组合。比如索引有10，20，30几个值，那么被锁住的区间可能会是(-∞,10]，(10,20]，(20,30]，(30,+∞)。

Next-Key Lock 加锁实践

通过SQL执行可以更好地理解Next-Key Lock到底是如何解决幻读的，执行过程如下：

1. 首先第一步Server层会来查询数据
2. 存储引擎根据查询条件查到数据之后对数据进行加锁，Record Lock或者间隙锁，然后返回数据
3. Server层拿到数据之后调用API去存储引擎更新数据
4. 最后存储引擎返回结果，流程结束

创建一个测试表来说明，user表有4个字段，id是主键索引，name是唯一索引，age是普通索引，city没有索引，然后插入一些测试数据。

下面区分一下几种情况来说明是怎么加Next-Key Lock的，然后就能理解为什么会没有幻读的问题了。

没有索引

更新语句update user set city='nanjing' where city='wuhan'会发生什么？

因为city是没有索引的，所以存储引擎只能给所有的记录都加上锁，然后把数据都返回给Server层，然后Server层把city改成nanjing，再更新数据。

因此，首先Record Lock会锁住现有的7条记录，间隙锁则会对主键索引的间隙全部加上间隙锁。

所以，更新的时候没有索引是非常可怕的一件事情，相当于把整个表都给锁了，那表都给锁了当然不存在幻读了。

普通索引

假设一个语句select * from user where age=20 for update。

因为age是一个普通索引，存储引擎根据条件过滤查到所有匹配age=20的记录，给他们加上写锁，间隙锁会加在(10,20)，(20,30)的区间上，因此现在无论怎样都无法插入age=20的记录了

为什么要锁定这两个区间？如果不锁定这两个区间的话，那么还能插入比如id=11,age=20或者id=21,age=20的记录，这样就存在幻读了。

（那实际上写锁不光是在会加在age普通索引上，还会加在主键索引上，因为数据都是在主键索引下对吧，这个肯定也要加锁的，为了看起来简单点，就不画出来了）

唯一&主键索引

如果查询的是唯一索引又会发生什么呢？比如有查询语句select * from user where name='b' for update。

上面我们提到过，如果是唯一索引或者主键索引的话，并且是等值查询，实际上会发生锁降级，降级为Record Lock，就不会有间隙锁了。

因为主键或者唯一索引能保证值是唯一的，所以也就不需要再增加间隙锁了。

很显然，是无法插入name=b的的记录的，也不存在幻读问题。

如果是范围查询比如id>1 and id<11呢，实际上也是一样的锁定方式，不再赘述。

相比稍微有点不同的是上面也说过，唯一索引不光锁定唯一索引，还会锁定主键索引，主键索引的话只要锁定主键索引就行了。

Next-Key Lock 加锁规则总结

两个“原则”、两个“优化”和一个“BUG”

1. 原则1：加锁的基本单位是 next-key lock。Next-Key Lock 是左开右闭区间。
2. 原则2：查找过程中访问到的对象才会加锁。

1. 优化1：索引上的等值查询，给唯一索引加锁的时候，Next-Key Lock 退化为行锁。
2. 优化2：索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，Next-Key Lock 退化为间隙锁。

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

Next-Key Lock 加锁案例

创建一个测试表和插入若干数据：

CREATE TABLE `t` (
  `id` int(11) NOT NULL,
  `normal_index` int(11) NOT NULL,
  `no_index` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `normal_index` (`normal_index`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

insert into t values(0,0,0),(5,5,5),(10,10,10),(15,15,15),(20,20,20),(25,25,25);

案例一：等值查询间隙锁

由于表 t 中没有 id=7 的记录，用上面的加锁规则分析如下：

1. 根据原则 1，加锁单位是 next-key lock，session A 加锁范围就是 (5,10]；
2. 同时根据优化 2，这是一个等值查询 (id=7)，而 id=10 不满足查询条件，next-key lock 退化成间隙锁，因此最终加锁的范围是 (5,10)。

所以，session B 要往这个间隙里面插入 id=8 的记录会被锁住，但是 session C 修改 id=10 这行是可以的。

案例二：非唯一索引（覆盖索引）等值锁

分析如下：

1. 根据原则 1，加锁单位是 next-key lock，因此会给 (0,5] 加上 next-key lock。
2. 要注意 c 是普通索引，因此仅访问 c=5 这一条记录是不能马上停下来的，需要向右遍历，查到 c=10 才放弃。根据原则 2，访问到的都要加锁，因此要给 (5,10] 加 next-key lock。
3. 但是同时这个符合优化 2：等值判断，向右遍历，最后一个值不满足 c=5 这个等值条件，因此退化成间隙锁 (5,10)。
4. 根据原则 2 ，只有访问到的对象才会加锁，这个查询使用覆盖索引，并不需要访问主键索引，所以主键索引上没有加任何锁，这就是为什么 session B 的 update 语句可以执行完成，但 session C 要插入一个 (7,7,7) 的记录，就会被 session A 的间隙锁 (5,10) 锁住。

例子中，lock in share mode 只锁覆盖索引，但是如果是 for update 就不一样了。 执行 for update 时，系统会认为你接下来要更新数据，因此会顺便给主键索引上满足条件的行加上行锁。

这个例子说明，锁是加在索引上的；同时，它表明的是，如果要用 lock in share mode 来给行加读锁避免数据被更新的话，就必须得绕过覆盖索引的优化，在查询字段中加入索引中不存在的字段。比如，将 session A 的查询语句改成 select d from t where c=5 lock in share mode。

案例三：主键索引范围锁

例子开始前，看如下两条SQL，可以先思考一下这个问题：对于这个表 t，下面这两条查询语句，加锁范围相同吗？

SELECT * FROM t WHERE id=10 FOR UPDATE;
SELECT * FROM t WHERE id>=10 and id <11 FOR UPDATE;

在逻辑上，这两条查语句肯定是等价的，但是它们的加锁规则不太一样。

语句1，会退化成行锁；语句2分析如下。

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

所以，session A 这时候锁的范围就是主键索引上，行锁 id=10 和 next-key lock(10,15]。这样，session B 和 session C 的结果就显而易见了。

这里需要注意一点，首次 session A 定位查找 id=10 的行的时候，是当做等值查询来判断的，而向右扫描到 id=15 的时候，用的是范围查询判断。

案例四：非唯一索引范围锁

需要注意的是，与案例三不同的是，案例四中查询语句的 where 部分用的字段是普通索引。

这次 session A 用字段 normal_index 来判断，加锁规则跟案例三唯一的不同是：在第一次用 normal_index=10 定位记录的时候，索引 normal_index上加了 (5,10] 这个 next-key lock 后，由于索引 normal_index 是非唯一索引，没有优化规则，也就是说不会蜕变为行锁，因此最终 sesion A 加的锁是，索引 normal_index 上的 (5,10] 和 (10,15] 这两个 next-key lock。

所以从结果上来看，sesson B 要插入（8,8,8) 的这个 insert 语句时就被堵住了

这里需要扫描到 normal_index=15 才停止扫描，是合理的，因为 InnoDB 要扫到 normal_index=15，才知道不需要继续往后找了。

案例五：唯一索引范围锁 BUG

session A 是一个范围查询，按照原则 1 的话，应该是索引 id 上只加 (10,15] 这个 next-key lock，并且因为 id 是唯一键，所以循环判断到 id=15 这一行就应该停止了。

但是实现上，InnoDB 会往前扫描到第一个不满足条件的行为止，也就是 id=20。而且由于这是个范围扫描，因此索引 id 上的 (15,20] 这个 next-key lock 也会被锁上。

所以你看到了，session B 要更新 id=20 这一行，是会被锁住的。同样地，session C 要插入 id=16 的一行，也会被锁住。

照理说，这里锁住 id=20 这一行的行为，其实是没有必要的。因为扫描到 id=15，就可以确定不用往后再找了。但实现上还是这么做了，因此认为这是个 bug。

案例六：非唯一索引上存在"等值"的例子

给表 t 插入一条新记录。

mysql> insert into t values(30,10,30);

新插入的这一行 c=10，也就是说现在表里有两个 normal_index=10 的行。虽然有两个 normal_index=10，但是它们的主键值 id 是不同的（分别是 10 和 30），因此这两个 normal_index=10 的记录之间，也是有间隙的。

例子如下：

delete 语句加锁的逻辑，其实跟 select ... for update 是类似的。

首先，session A 在遍历的时候，先访问第一个 c=10 的记录。同样地，根据原则 1，这里加的是 (c=5,id=5) 到 (c=10,id=10) 这个 next-key lock。

然后，session A 向右查找，直到碰到 (c=15,id=15) 这一行，循环才结束。根据优化 2，这是一个等值查询，向右查找到了不满足条件的行，所以会退化成 (c=10,id=10) 到 (c=15,id=15) 的间隙锁。

(c=5,id=5) 到 (c=10,id=10) 这个 next-key lock 区间左开右闭， (c=10,id=10) 到 (c=15,id=15) 的间隙锁两边都开区间，即 (c=5,id=5) 和 (c=15,id=15) 这两行上都没有锁，所以另外两个session的结果显而易见。

案例七：limit 语句加锁

沿用案例六中插入的记录，例子如下：

session A 的 delete 语句加了 limit 2。表 t 里 c=10 的记录其实只有两条，因此加不加 limit 2，删除的效果都是一样的，但是加锁的效果却不同。

可以看到，session C 的 insert 语句执行通过了，跟案例六的结果不同。

这是因为，delete 语句明确加了 limit 2 的限制，因此在遍历到 (c=10, id=30) 这一行之后，满足条件的语句已经有两条，循环就结束了。

因此，索引 c 上的加锁范围就变成了从（c=5,id=5) 到（c=10,id=30) 这个前开后闭区间。因此 insert 语句插入 c=12 是可以执行成功的。

例子表明：在删除数据的时候尽量加 limit。这样不仅可以控制删除数据的条数，让操作更安全，还可以减小加锁的范围。

案例八：一个死锁的例子

前面的例子中，在分析的时候，是按照 next-key lock 的逻辑来分析的，因为这样分析比较方便。最后再看一个案例，目的是说明：next-key lock 实际上是间隙锁和行锁加起来的结果。

例子如下：

分析如下：

1. session A 启动事务后执行查询语句加 lock in share mode，在索引 c 上加了 next-key lock(5,10] 和间隙锁 (10,15)；
2. session B 的 update 语句也要在索引 c 上加 next-key lock(5,10]并更新 ，进入锁等待；
3. 然后 session A 要再插入 (8,8,8) 这一行，被 session B 的间隙锁锁住。由于出现了死锁，InnoDB 让 session B 回滚。

此时，可能会有一个疑问：session B 的 next-key lock 不是还没申请成功吗？

其实是这样的，session B 的“加 next-key lock(5,10] ”操作，实际上分成了两步，先是加 (5,10) 的间隙锁，间隙锁与间隙锁之前不互斥（目的都是锁住一个间隙，不让操作），加锁成功；然后加 c=10 的行锁，这时候才被锁住的。

也就是说，在分析加锁规则的时候可以用 next-key lock 来分析。但是，具体执行的时候，是要分成间隙锁和行锁两段来执行的。

小结

上面的所有案例都是在可重复读隔离级别 (repeatable-read) 下验证的。

同时，可重复读隔离级别遵守两阶段锁协议，所有加锁的资源，都是在事务提交或者回滚的时候才释放的。

在最后的案例中，你可以清楚地知道 next-key lock 实际上是由间隙锁加行锁实现的。如果切换到读提交隔离级别 (read-committed) 的话，就好理解了，过程中去掉间隙锁的部分，也就是只剩下行锁的部分。

另外，在读提交隔离级别下还有一个优化，即：语句执行过程中加上的行锁，在语句执行完成后，就要把“不满足条件的行”上的行锁直接释放了，不需要等到事务提交。也就是说，读提交隔离级别下，锁的范围更小，锁的时间更短，这也是不少业务都默认使用读提交隔离级别的原因。

对 next-key lock 的概念有更清晰的认识，并且会用加锁规则去判断语句的加锁范围后，在业务需要使用可重复读隔离级别的时候，能够更细致地设计操作数据库的语句，解决幻读问题的同时，最大限度地提升系统并行处理事务的能力。