MySQL 笔记整理（21） --为什么我只改一行语句，锁这么多？

笔记记录自林晓斌（丁奇）老师的《mysql实战45讲》

（本篇内图片均来自丁奇老师的讲解，如有侵权，请联系我删除）

21） --为什么我只改一行语句，锁这么多？

　　之前我们介绍了间隙锁和next-key lock的概念，但是并没有说明加锁规则。所以今天我们就从加锁规则开始。但这个规则有两点要提前说明一下：

1. mysql后面的版本可能会改变加锁策略，所以这个规则受限于版本。即5.x系列 <= 5.7.24, 8.0系列 <=8.0.13.
2. 如果有bad case的话请提出来，大家一起学习。(这里我会关注丁奇老师这篇内容下的评论，如果确实有这种情况我会补充出来。)

　　因为间隙锁在可重复读隔离级别下才有效，所以本篇接下来的描述如果没有特殊说明，默认都是可重复读隔离级别。

　　这里包含两个“原则”，两个“优化”和一个“bug”

1. 原则1：加锁的基本单位是next-key lock。next-key lock是前开后闭区间。
2. 原则2：查找过程中访问到的对象才会加锁。
3. 优化1：索引上的等值查询，给唯一索引加锁的时候，next-key lock退化为行锁。
4. 优化2：索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock 退化为间隙锁。
5. 一个bug：唯一索引上的范围查询会访问到不满足条件的第一个值为止。

　　我们还是以上篇文章的表t为例，来解释一下这些规则，表t的建表语句和初始化语句如下：

create table `t` (
  `id` int(11) not null,
  `c` int(11) default null,
  `d` int(11) default null,
  primary key (`id`),
  key `c` (`c`)
) engine=innodb;

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,sessiona加锁范围是(5,10]；
2. 同时根据优化2，这是一个等值查询(id=7),而id=10不满足查询条件，next-key lock退化成间隙锁，因此最终加锁范围是（5,10）。

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

案例二：非唯一索引等值锁

　　第二个例子是关于覆盖索引上的锁：

 　　

　　　　　　　　只加在非唯一索引上的锁

　　看到这个例子，你是不是有一种“该锁的不锁，不该锁的乱锁”的感觉？我们来分析一下吧。

　　这里的session a要给索引c上c=5这一行加上读锁。

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.

案例三：主键索引范围锁

　　第三个例子是关于范围查询的。

　　举例之前，我们先来思考一下，对于我们这个表t，下面这两条查询语句，加锁范围相同嘛?

mysql> select * from t where id=10 for update;
mysql> select * from t where id>=10 and id<11 for update;

　　你可能会想，id为int类型，这两个语句是等价的吧？其实，它们并不完全等价。当然，在逻辑上这两条语句还是等价的。但实际上它们的加锁规则不太一样。现在，我们就让session a执行第二个查询语句，来看看加锁效果。

　　　　主键索引上范围查询的锁

　　现在我们利用前面提到的加锁规则，来分析一下session a会加什么锁呢？

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部分用的是字段c。

　　

　　　　　　　　非唯一索引范围锁

　　这次session a用字段c来判断，加锁规则跟案例三唯一不同的是：在第一次用c=10定位记录的时候，索引c上加了(5,10]这个next-key lock后，由于索引c是唯一索引，没有优化规则，也就是说不会退变为行锁，因此最终session a加的锁是，索引c上的(5,10]和(10,15]这两个next-key lock。所以结果上看，session b要插入（8,8,8）的这个insert语句就被堵住了。

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

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

 　　前面的四个案例，我们已经用到了加锁规则中的两个原则和两个优化，接下来再看一个关于加锁规则中的bug的案例。

　　　　唯一索引范围锁的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这一行的行为，其实是没有必要的。因为扫描到了id=15，就可以确定不用往后再找了。但实现上还是这么做了，因此认为这是一个bug。（这里原文中丁奇老师曾与社区专家讨论过，官方bug系统上也有提到过这个，但并未被verified。所以是不是bug这个事儿，如果有别的见解，欢迎提出来。）

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

　　接下来的例子，是为了更好地说明“间隙”这个概念。这里，我给表t插入一条新记录。

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

　　新插入的这一行c=10，也就是说现在表里有两个c=10的记录。那么，这时候索引c上的间隙是什么状态呢？你要知道，由于非唯一索引上包含了主键的值，所以是不可能存在“相同”的两行的。

 

　　　　非唯一索引等值的例子

　　可以看到，虽然有两个c=10，但是它们的主键值id是不同的（分别是10和30），因此这两个c=10的记录之间，也是有间隙的。图中画出了索引c上的主键id。为了跟间隙锁的开区间形式进行区别，使用（c=10，id=30）这样的形式，来表示索引上的一行。现在我们来验证一下案例六。

　　这次我们用delete语句来验证。注意，delete语句加锁的逻辑是，其实跟select...for update是类似的，也就是我在文章开始总结的两个“原则”，两个“优化”，和一个“bug”.

　　　　delete 示例

　　这时，session a在遍历的时候，先访问第一个c=10的记录。同样地，根据原则1，这里加的是(c=15,id=15)这一行，循环才结束。根据优化2，这是一个等值查询，向右查找到了不满足条件的行，所以会退化成(c=10,id=10)到(c=15,id=15)的间隙锁。也就是说，这个delete语句在索引c上的加锁范围，就是下图中蓝色区域覆盖的部分。

　　　　　　                                 delete加锁效果示例

　　这个蓝色区域左右两边都是虚线，表示开区间，即(c=5,id=5)和(c=15,id=15)这两行上都没有锁。

案例七：limit语句加锁

　　例子6也有一个对照案例，场景如下所示：

 

　　　　　　　　limit语句加锁

　　这个例子里，session a的delete语句加了limit 2.你知道表t里c=10的记录其实只有两条，因此加不加limit 2，删除效果都是一样的，但是加锁的效果却不同。可以看到，session b的insert语句执行通过了，跟案例六的结果不同。这是因为，案例七里的delete语句明确加了limit 2的限制，因此在遍历到(c=10,id=30)这一行之后，满足条件的语句已经有两条，就循环结束了。因此，索引c上加的范围锁就变成了从(c=5,id=5)到(c=10,id=30)这个前开后闭区间，如下图所示。

 

　　　　　　　　　　带 limit 2的加锁效果

　　可以看到，(c=10,id=30)之后的这个间隙并没有在加锁范围里，因此insert语句插入c=12是可以执行成功的。这个例子对我们实践的指导意义是，在删除数据的时候尽量加limit 1.这样不仅可以控制删除数据的条数，让操作更安全，还可以减小加锁的范围。

案例八：一个死锁的例子

　　前面的例子中，我们在分析的时候，是按照next-key lock的逻辑来分析的，因为这样分析比较方便。最后我们再看一个案例，目的是说明：next-key lock实际上是间隙锁和行锁加起来的结果。你一定会疑惑，这个概念不是一开始就说了吗？不要着急，我们先俩看看下面这个例子：

　　　　　　　　案例八的操作序列

　　现在，我们按时间顺序来分析一下为什么是这样的结果。

1. session a启动事务后执行查询语句加lock in share mode,在索引c上加了next-key lock(5,10]和间隙锁(10,15)；
2. session b的udpate语句也要在索引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)下验证的，在这个隔离级别下遵守两阶段锁协议，所有加锁的资源，都是在事务提交或者回滚的时候才释放的。

 

　　如果小伙伴们想要重现上面的例子可以搜一下具体的流程，我再重现的时候遇到了几个小坑，希望大家可以避免。（mysql 5.7.23）
　　1. 数据库的隔离级别要是 rr（可重复读） 才行。
　　2. 要关闭mysql的自动提交。
　　3. 不要使用workbench这些工具，一般情况下即使你开多个page也是在同一个session中执行的。
　　4. 可以多开几个控制台来模拟不同的session。
　　5. 使用start transaction with consistent snapshot;