加微信heibaifk,网盘停止更新

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);

接下来的例子基本都是配合着图片说明的,所以我建议你可以对照着文稿看,有些例子可能会“毁三观”,也建议你读完文章后亲手实践一下。

案例一:等值查询间隙锁

第一个例子是关于等值条件操作间隙:

图1 等值查询的间隙锁

由于表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这行是可以的。

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

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

图2 只加在非唯一索引上的锁

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

这里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执行第二个查询语句,来看看加锁效果。

图3 主键索引上范围查询的锁

现在我们就用前面提到的加锁规则,来分析一下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。

图4 非唯一索引范围锁

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

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

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

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

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

图5 唯一索引范围锁的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。

我也曾找社区的专家讨论过,官方bug系统上也有提到,但是并未被verified。所以,认为这是bug这个事儿,也只能算我的一家之言,如果你有其他见解的话,也欢迎你提出来。

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

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

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

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

图6 非唯一索引等值的例子

可以看到,虽然有两个c=10,但是它们的主键值id是不同的(分别是10和30),因此这两个c=10的记录之间,也是有间隙的。

图中我画出了索引c上的主键id。为了跟间隙锁的开区间形式进行区别,我用(c=10,id=30)这样的形式,来表示索引上的一行。

现在,我们来看一下案例六。

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

图7 delete 示例

这时,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)的间隙锁。

也就是说,这个delete语句在索引c上的加锁范围,就是下图中蓝色区域覆盖的部分。

图8 delete加锁效果示例

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

案例七:limit 语句加锁

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

图9 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)这个前开后闭区间,如下图所示:

图10 带limit 2的加锁效果

可以看到,(c=10,id=30)之后的这个间隙并没有在加锁范围里,因此insert语句插入c=12是可以执行成功的。

这个例子对我们实践的指导意义就是,在删除数据的时候尽量加limit。这样不仅可以控制删除数据的条数,让操作更安全,还可以减小加锁的范围。

案例八:一个死锁的例子

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

你一定会疑惑,这个概念不是一开始就说了吗?不要着急,我们先来看下面这个例子:

图11 案例八的操作序列

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

  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的概念有更清晰的认识,并且会用加锁规则去判断语句的加锁范围。

在业务需要使用可重复读隔离级别的时候,能够更细致地设计操作数据库的语句,解决幻读问题的同时,最大限度地提升系统并行处理事务的能力。

经过这篇文章的介绍,你再看一下上一篇文章最后的思考题,再来尝试分析一次。

我把题目重新描述和简化一下:还是我们在文章开头初始化的表t,里面有6条记录,图12的语句序列中,为什么session B的insert操作,会被锁住呢?

图12 锁分析思考题

另外,如果你有兴趣多做一些实验的话,可以设计好语句序列,在执行之前先自己分析一下,然后实际地验证结果是否跟你的分析一致。

对于那些你自己无法解释的结果,可以发到评论区里,后面我争取挑一些有趣的案例在文章中分析。

你可以把你关于思考题的分析写在留言区,也可以分享你自己设计的锁验证方案,我会在下一篇文章的末尾选取有趣的评论跟大家分享。感谢你的收听,也欢迎你把这篇文章分享给更多的朋友一起阅读。

上期问题时间

上期的问题,我在本期继续作为了课后思考题,所以会在下篇文章再一起公布“答案”。

这里,我展开回答一下评论区几位同学的问题。

  • @令狐少侠 说,以前一直认为间隙锁只在二级索引上有。现在你知道了,有间隙的地方就可能有间隙锁。
  • @浪里白条 同学问,如果是varchar类型,加锁规则是什么样的。
    回答:实际上在判断间隙的时候,varchar和int是一样的,排好序以后,相邻两个值之间就有间隙。
  • 有几位同学提到说,上一篇文章自己验证的结果跟案例一不同,就是在session A执行完这两个语句:
begin;
select * from t where d=5 for update; /*Q1*/

以后,session B 的update 和session C的insert 都会被堵住。这是不是跟文章的结论矛盾?

其实不是的,这个例子用的是反证假设,就是假设不堵住,会出现问题;然后,推导出session A需要锁整个表所有的行和所有间隙。

评论区留言点赞板:

@ 某、人 、@郭江伟 两位同学尝试分析了上期问题,并给了有启发性的解答。

精选留言

  • 堕落天使
    老师,您好。假期的没跟上,今天补到了这节课,看了之后有几点不是太明白。望能解答一下。
    1. 索引c上的锁算不算是行锁。假如索引c上的next-key lock为(0,5] (5,10],那么5算不算是c上的行锁?
    2. 在案例六中,执行 “delete from t where c=10;” 语句,索引c上的next-key lock是(5,10],(10,10],(10,15)。那么主键索引上的锁是什么呢?是只有行锁,锁住的是 (10,10,10) 和 (30,10,30) 两行吗?
    3. 也是在案例六中,session A不变,在session B中执行 “update t_20 set d=50 where c=5;”、“update t_20 set d=50 where c=15;”、“insert into t_20 values(40,15,40);”均执行成功,但执行“insert into t_20 values(50,5,50);” 时,却被阻塞。为什么呢?具体执行语句如下
    session A
    mysql> begin;
    mysql> explain delete from t_20 where c=10;
    id select_type table partitions type possible_keys key key_len ref rows filtered Extra
    1 DELETE t_20 range c c 5 const 2 100 Using where
    mysql> delete from t_20 where c=10;

    session B
    mysql> update t_20 set d=50 where c=5;
    Query OK, 1 row affected (0.01 sec)
    Rows matched: 1 Changed: 1 Warnings: 0

    mysql> update t_20 set d=50 where c=15;
    Query OK, 1 row affected (0.00 sec)
    Rows matched: 1 Changed: 1 Warnings: 0

    mysql> insert into t_20 values(40,15,40);
    Query OK, 1 row affected (0.00 sec)

    mysql> explain insert into t_20 values(50,5,50);
    +----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
    | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    +----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
    | 1 | INSERT | t_20 | NULL | ALL | c | NULL | NULL | NULL | NULL | NULL | NULL |
    +----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
    1 row in set (0.00 sec)

    mysql> insert into t_20 values(50,5,50);
    (block)

    我使用的mysql版本是:5.7.23-0ubuntu0.16.04.1
    show variables的结果太多,我截取了一部分,或许对您分析有帮助:
    innodb_version 5.7.23
    protocol_version 10
    slave_type_conversions
    tls_version TLSv1,TLSv1.1
    version 5.7.23-0ubuntu0.16.04.1
    version_comment (Ubuntu)
    version_compile_machine x86_64
    version_compile_os Linux
    2019-01-03 18:40
    作者回复

    1. Next-key lock 就是间隙锁➕行锁,所以包含=5这一行
    2. 对
    3. (c=5,id=50)是在这个gap里哦,你试试插入(1,5,50)对比一下。好问题

    2019-01-03 22:39

  • 张三
    Happy New Year !这个专栏绝对是极客时间最好我买过最值的专栏。
    2018-12-31 15:53
  • 约书亚
    早晨睡不着打开极客时间一看,竟然更新了。今天是周日而且在假期中哎...
    2018-12-31 06:32
    作者回复

    风雨无阻 节假日不休,包括元旦和春节😄

    2018-12-31 08:48

  • 郭江伟
    老师这次的留下的问题,语句跟上次不一样,上期问题语句是select id from t where c>=15 and c<=20 order by c desc for update;;这次缺少了 order by c desc ,不加desc的话insert into t values(6,6,6);不会被堵塞;
    根据优化3:索引上的等值查询,在向右遍历时且最后一个值不满足等值条件的时候next-key lock退化为间隙锁;
    问题中的sql语句加了desc ,是向左扫描,该优化用不上,所以下限10是闭区间,为了防止c为10的行加入,需要锁定到索引c键(5,5)
    此例中insert into t values(6,5,6) 会堵塞,insert into t values(4,5,6) 不会堵塞,
    2018-12-31 14:11
    作者回复

    嗯你说的对

    不过是我少打一个词了,加上去了,要desc哦

    重新分析下😄

    2018-12-31 16:14

  • 乾坤
    您好,关于"优化 2:索引上的等值查询,向右遍历时且最后一个值不满足等值条件的时候,next-key lock 退化为间隙锁。",我觉得改为"从第一个满足等值条件的索引记录开始向右遍历到第一个不满足等值条件记录,并将第一个不满足等值条件记录上的next-key lock 退化为间隙锁"更明确些
    2019-01-01 22:11
    作者回复

    感觉没大差别,嗯嗯,理解就好😄

    2019-01-02 00:52

  • HuaMax
    首先老师新年快乐,学习专栏受益良多!
    上期问过老师的问题已了解答案,锁是加在索引上的。再尝试回答问题。c上是普通索引,根据原则2,访问到的都要加锁,在查询c>=15这个条件时,在查找到15后加锁(10,15],继续往右查找,按理说不会锁住6这个索引值,但查询语句中加了order by c desc,我猜想会优化为使用c<=20这条语句,查找到20后往左查找,这样会访问到15左边的值10,从而加锁(5,10],不知我理解对否?
    2019-01-01 10:20
    作者回复

    新年好

    对的👍🏿

    2019-01-01 12:04

  • Geek_9ca34e
    老师,你好:
    我练习实例的时候发现一个问题:如 案例五:唯一索引范围锁 bug
    begin;
    select * from t where id>10 and id<=15 for update;
    1、执行如上语句加锁范围(10,15]和(15,20];
    2、因为10未加锁,所以我单独再开一个连接,执行delete from t where id=10;不会锁等待,能正常删除;
    3、但是我再执行insert into t values(10,10,10); 语句会等待,无法正常执行;
    4、经过分析我发现第一个连接执行的语句的加锁范围已经变成(5,15]和(15,20],代表锁蔓延了;这是什么原因呢?
    2019-01-09 16:34
    作者回复

    好问题,我会加到答疑文章中,
    Gap是一个动态的概念

    2019-01-09 22:24

  • 往事随风,顺其自然
    session A
    mysql> select * from t where c>=15 and c<=20 order by c desc lock in share mode;
    +----+------+------+
    | id | c | d |
    +----+------+------+
    | 20 | 20 | 20 |
    | 15 | 15 | 15 |
    +----+------+------+
    2 rows in set (0.00 sec)

    session b
    mysql> insert into t values(6,6,6);
    Query OK, 1 row affected (0.00 sec)
    可以插入成功,没有被锁住
    2019-01-01 21:34
    作者回复

    Explain结果发一下,还有show variables 结果也发下

    2019-01-02 00:48

  • 往事随风,顺其自然
    这和分两步有什么关系?
    (5,10]已经是被锁住,分不分两步来加锁,这个间隙和行锁都被锁住了,session b应该是拿不到锁才对。
    2019-01-01 21:24
  • 老师在案列一中update t set d=d+1 where id=7 中id是主键也是唯一索引,按优化1应该退化成行锁才对,为什么insert into t values(8,8,8)会被锁住,我是那儿理解错了?
    2019-01-11 18:07
    作者回复

    这一行存在的时候是行锁,这一行不存在,那就是间隙锁啦。

    insert into t values(8,8,8)是被主键上(5,10)的间隙锁锁住的

    2019-01-11 19:15

  • 鸠翱
    老师我今天在回顾的时候又想到一个新问题,为什么RR级别下要以next-key lock作为加锁的基本单位呢?
    比如说案例5中的那个例子,我将其修改成select * from t where id > 10 and id < 15 for upadate,按照加锁规则,需要对(10,15]上锁,那么按照逻辑来看,15的那个行锁其实没必要的(难道是有必要的嘛?),既然next-key lock本质也是先加间隙锁再加行锁,为什么非要把那个行锁也加上,就是因为next-key lock是加锁基本单位嘛?
    2019-01-10 10:55
    作者回复

    代码实现上是这样子的。。

    2019-01-11 01:14

  • 袁伟
    感谢老师,用这些知识成功的找到了最近出现的死锁
    2019-01-10 00:10
    作者回复

    👍🏿 这种感觉最棒

    2019-01-10 09:53

  • neptunesong
    之前问过您这篇文章http://hedengcheng.com/?p=771中关于"一个复杂的sql"例子,不知您是否还记得。我按照您说的进行pubtime=20进行测试,没有发现被lock住,说明针对pubtime<20加的是gap锁,不是next key锁。这个和我们案例4中场景一样,但结果不一样。不确定是哪里想错了。求解惑:)
    2019-01-08 15:46
    作者回复

    我是这么验证的,
    session A:
    begin;
    delete from t1 where pubtime>1 and pubtime<20 and userid='hdc' and comment is not null;

    sessionB:
    update t1 set comment='a' where pubtime=20 and userid='bbb';
    (blocked)

    你的验证方法贴一下

    2019-01-10 19:14

  • 熠辰
    老师,你好,麻烦问下对于规则当中,优化1中针对的唯一索引加锁,这块,对于主键索引是否也可以理解为唯一索引的加锁规则,对于案例2最后select id更改为select d测试,update会被阻塞,如果按照优化1的规则看的话,是因为存在的行锁导致的阻塞,不知道是否理解的正确,希望老师帮忙解答!!!
    2019-01-08 11:30
    作者回复

    对,主键索引是唯一索引的一种,在我们这个规则里面是一样的

    2019-01-10 19:04

  • undifined
    遇到一个有趣的问题,在老师的解答下终于弄明白了:

    CREATE TABLE z (
    id INT PRIMARY KEY AUTO_INCREMENT,
    b INT,
    KEY b(b)
    )
    ENGINE = InnoDB
    DEFAULT CHARSET = utf8;

    INSERT INTO z (id, b)
    VALUES (1, 2),
    (3, 4),
    (5, 6),
    (7, 8),
    (9, 10);

    session A

    BEGIN;
    SELECT *
    FROM z
    WHERE b = 6 FOR UPDATE;

    session B
    INSERT INTO z VALUES (0, 4);
    这里为什么会被锁住

    答案比较长,写在我自己的笔记里了,地址是 https://helloworlde.github.io/blog/blog/MySQL/MySQL-%E4%B8%AD%E5%85%B3%E4%BA%8Egap-lock-next-key-lock-%E7%9A%84%E4%B8%80%E4%B8%AA%E9%97%AE%E9%A2%98.html

    大家可以看看
    2019-01-07 22:11
    作者回复

    好问题,质量很高的笔记

    2019-01-10 18:53

  • 信信
    接上一个提问,老师回答:第二个语句把第一个gap变成(1,10]了。
    对此非常惊讶,相当于当前线程的锁的范围可以被动受别的线程影响,感觉打开了新世界的大门。。。。。。
    另外还有一个问题:执行 explain select c from t where c!=1;
    发现possible_keys和key都是c,但其实看着并没有用到树搜索功能,只是遍历了索引。
    网上基本都说!=用不了索引,所以这种说法是不严谨的?
    2019-01-07 17:10
    作者回复

    是的,不严谨

    用了索引,但是没有用到索引的快速定位能力

    2019-01-07 17:50

  • 信信
    老师您好,自己基于文中开头的表做了一个实验,
    session1:
    mysql> begin;
    mysql> explain select c from t where c >5 lock in share mode;
    分析:(5,10],(10,15],(15,20],(20,25],(25,正无穷)有锁。
    session2:
    mysql> update t set c = 5 where c = 1;#(执行成功)
    mysql> update t set c = 1 where c = 5;#(执行成功)
    mysql> update t set c = 5 where c = 1;#(阻塞)
    最后一条阻塞,无法用原理分析,肯请老师解答。
    2019-01-07 12:13
    作者回复

    第二个语句把第一个gap变成(1,10]了

    第三个update的逻辑里面,包含了“要插入一个c=5的行”

    好问题

    2019-01-07 15:01

  • 进阶的码农
    --
    LATEST DETECTED DEADLOCK
    --
    2018-12-18 21:03:25 0x7f33248e0700
    *** (1) TRANSACTION:
    TRANSACTION 404074133, ACTIVE 1 sec starting index read
    mysql tables in use 1, locked 1
    LOCK WAIT 3 lock struct(s), heap size 1136, 2 row lock(s)
    MySQL thread id 176, OS thread handle 139857630418688, query id 36851897 127.0.0.1 user001 Sending data
    select
    bikeId, lat, lng, update_time, state, accuracy
    from mbk_location_rawdata
    where state = 0
    and update_time<'2018-12-18 20:57:25'
    LIMIT 500
    for update/*user001*/
    *** (1) WAITING FOR THIS LOCK TO BE GRANTED:
    RECORD LOCKS space id 29488 page no 269 n bits 344 index PRIMARY of table `mbk_bike`.`mbk_location_rawdata` trx id 404074133 lock_mode X locks rec but not gap waiting
    Record lock, heap no 23 PHYSICAL RECORD: n_fields 9; compact format; info bits 32
    *** (2) TRANSACTION:
    TRANSACTION 404074140, ACTIVE 0 sec updating or deleting
    mysql tables in use 1, locked 1
    4 lock struct(s), heap size 1136, 3 row lock(s), undo log entries 1
    MySQL thread id 165, OS thread handle 139857633347328, query id 36851918 127.0.0.1 user001 updating
    delete from mbk_location_rawdata
    where bikeId = 'aMho6x8BtC'/*user001*/
    *** (2) HOLDS THE LOCK(S):
    RECORD LOCKS space id 29488 page no 269 n bits 344 index PRIMARY of table `mbk_bike`.`mbk_location_rawdata` trx id 404074140 lock_mode X locks rec but not gap
    Record lock, heap no 23 PHYSICAL RECORD: n_fields 9; compact format; info bits 32
    *** (2) WAITING FOR THIS LOCK TO BE GRANTED:
    RECORD LOCKS space id 29488 page no 201 n bits 1000 index idx_time of table `mbk_bike`.`mbk_location_rawdata` trx id 404074140 lock_mode X locks rec but not gap waiting
    Record lock, heap no 105 PHYSICAL RECORD: n_fields 2; compact format; info bits 0
    *** WE ROLL BACK TRANSACTION (1)
    ------------
    TRANSACTIONS
    问题:
    1.发生死锁的原因?
    2.死锁日志transaction2里delete语句的条件是bikeId,就算获取锁也是获取bikeId的索引,为什么死锁日志里项[WAITING FOR THIS LOCK TO BE GRANTED] 是indx_time,这是我最疑惑的地方
    希望老师拯救我,一直没想通,网上也没有搜到类似的问题
    2019-01-05 19:27
    作者回复

    这个就是典型的lock ... for update会出现的问题。这两个事务的加锁顺序没有保持一致。

    先回答你第二个问题,一个delete语句,可不只是会锁bikeid 这个索引哦,假设要删除的行的时间字段值是T,也会去idx_time的T上加行锁的。

    如果要解决这个问题,一种方法是改变锁顺序。只考虑这两个语句的话,transaction 2查出bikeid对应的T值,先去执行一个where update_time=T for update.

    不过一般如果死锁不严重,问题不大,重试事务就可以了。

    2019-01-05 21:40

  • 进阶的码农
    老师你好问一个最近项目中遇到的死锁,困扰了我好久,一直不知道原因,下面给出隔离级别、表结构、业务逻辑、死锁log
    1.隔离级别
    rc
    2.表结构
    CREATE TABLE `mbk_location_rawdata` (
    `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID',
    `bikeId` varchar(15) NOT NULL,
    `lat` decimal(11,8) NOT NULL DEFAULT '0.00000000' ,
    `lng` decimal(11,8) NOT NULL DEFAULT '0.00000000',
    `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ',
    `state` int(8) NOT NULL DEFAULT '0' ,
    `accuracy` smallint(6) NOT NULL DEFAULT '0' ,
    PRIMARY KEY (`id`),
    UNIQUE KEY `uniq_bikeid` (`bikeId`),
    KEY `idx_time` (`update_time`) USING BTREE,
    KEY `idx_state` (`state`)
    ) ENGINE=InnoDB AUTO_INCREMENT=8897633 DEFAULT CHARSET=utf8
    3.业务逻辑
    @Transaction
    processData(timeParam){
    //对应sql select * from test_rawdata where state=0 and update_time<timeParam for update limit 500;
    bikeIds = findForUpdate();
    //取出数据,然后先状态改成2
    //对应sql update test_rawdata set state = 2 where bikeId in(bikeIds);
    updateData(bikeIds);
    }
    @Transaction
    deleteData(bikeIdParam){
    //sql delete from mbk_location_rawdata
    where bikeId = bikeIdParam
    }
    留言太长,下边一条跟着死锁日志
    2019-01-05 19:27
  • Mr.Strive.Z.H.L
    老师你好:
    在读提交模式下,一般场景是没有间隙锁的,因此将binlog设置为row格式,可以解决binlog日志顺序和语句实际执行顺序不一致的问题(幻读那一篇提到的问题,因为row格式是直接记录数据的结果改变)
    那么,如果使用RR模式,把间隙锁关闭,将binlog设置为row格式。这样既可以实现重复读,又可以减小锁的粒度。虽然这样的话,幻读的情况无法解决,但是幻读一般来说影响并不大。
    综上,为什么没有人在RR模式下,关闭间隙锁,开启row格式的binlog呢??
    2019-01-05 11:28
    作者回复

    我觉得可能一方面是很多人并不知道这个参数😄

    不过幻读如果确认不需要,一般表示可重复读也不需要,不如直接改RC+row格式的binlog😄

    我还没有碰到过你说的这种需求场景

    2019-01-05 21:09