Mysql 行锁（记录锁、间隙锁、临键锁）实战，基于InnoDB

于 2023-04-16 18:44:22 发布
阅读量510 收藏 2
点赞数
分类专栏： mysql 文章标签： mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38597669/article/details/130181149
版权
本文通过实例分析了MySQL8.0.32中InnoDB存储引擎在RR事务隔离级别下的行锁机制，包括主键索引、唯一索引和普通索引的加锁情况。详细探讨了等值查询和范围查询时的锁类型、锁模式，并揭示了非主键唯一索引的范围查询存在的优化问题。
摘要由CSDN通过智能技术生成

文章目录

前言

通过上一篇我们了解了行锁的很多细节，这里结合实战对各种情况演练一番，更深入的理解MySql加锁机制。

PS：本文基于mysql8.0.32, InnoDB存储引擎，RR事务隔离级别。

一、案例

1：表结构

mysql> show create table test\G;
*************************** 1. row ***************************
       Table: test
Create Table: CREATE TABLE `test` (
  `id` bigint NOT NULL,
  `num` int NOT NULL,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '',
  `key_id` int unsigned DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ind_key` (`key_id`) USING BTREE,
  KEY `ind_num` (`num`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci

2：表数据

mysql> select * from test;
+----+-----+------+--------+
| id | num | name | key_id |
+----+-----+------+--------+
|  5 |   5 | fd   |      5 |
|  7 |   7 | ty   |      7 |
| 12 |  12 | io   |     12 |
| 18 |  12 | jk   |     18 |
| 23 |  22 | po   |     23 |
| 24 |  22 | cv   |     24 |
| 31 |  28 | ku   |     31 |
| 42 |  35 | kl   |     49 |
+----+-----+------+--------+

这里先复习下上一章的知识点：
1）行锁细分为记录锁，间隙锁，临键锁。
2）针对主键，记录锁是确定的行，如id=18；
对于间隙锁有（负无穷，5），（5，7）…(31,42),(42,正无穷) ，单位锁定范围遵循左开又开原则 ；
对于临键锁，是记录锁与间隙锁的结合，单位锁定范围遵循左开右闭原则 ，则有
（负无穷，5]，（5，7]…(31,42],(42,正无穷) 。
3) 加锁的基本单位是临键锁，视情况会被优化成记录锁或间隙锁。

二、实战分析

如果未命中索引会退化为表锁，因此我们只分析命中索引的情况，命中索引可以按索引类别分为主键，唯一索引，普通索引三种。

1：主键索引

1：select * from test where id=18 for update;

查询数据存在。

mysql> select * from performance_schema.data_locks\G;
*************************** 1. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:1064:2138320015896
ENGINE_TRANSACTION_ID: 1420
            THREAD_ID: 56
             EVENT_ID: 694
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: NULL
OBJECT_INSTANCE_BEGIN: 2138320015896
            LOCK_TYPE: TABLE
            LOCK_MODE: IX
          LOCK_STATUS: GRANTED
            LOCK_DATA: NULL
*************************** 2. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:4:5:2138303895576
ENGINE_TRANSACTION_ID: 1420
            THREAD_ID: 56
             EVENT_ID: 694
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: PRIMARY
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X,REC_NOT_GAP
          LOCK_STATUS: GRANTED
            LOCK_DATA: 18

可以看到除有表级的意向排它锁（IX）,针对id=18这行数据加了记录锁。

2：select * from test where id=20 for update;

查询数据不存在。

mysql> select * from performance_schema.data_locks\G;
*************************** 1. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:1064:2138320015896
ENGINE_TRANSACTION_ID: 1421
            THREAD_ID: 56
             EVENT_ID: 716
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: NULL
OBJECT_INSTANCE_BEGIN: 2138320015896
            LOCK_TYPE: TABLE
            LOCK_MODE: IX
          LOCK_STATUS: GRANTED
            LOCK_DATA: NULL
*************************** 2. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:5:6:2138303895576
ENGINE_TRANSACTION_ID: 1421
            THREAD_ID: 56
             EVENT_ID: 716
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: ind_key
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X,GAP
          LOCK_STATUS: GRANTED
            LOCK_DATA: 23, 23

可以看到除有表级的意向排它锁（IX）,还加了id=23这行数据的间隙锁。
加锁过程：1：在主键索引上查找id=20这一行数据，没有查到
2：继续沿着主键索引向叶子结点方向查找，找到第一个大于20的行，即id=23;
3:然后获取id=23这行数据的临键锁，因为是主键索引，所以退化为间隙锁

3：select * from test where id >7 and id<=18 for update;

范围查询。

mysql> select * from performance_schema.data_locks\G;
*************************** 1. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:1064:2138320015896
ENGINE_TRANSACTION_ID: 1424
            THREAD_ID: 56
             EVENT_ID: 775
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: NULL
OBJECT_INSTANCE_BEGIN: 2138320015896
            LOCK_TYPE: TABLE
            LOCK_MODE: IX
          LOCK_STATUS: GRANTED
            LOCK_DATA: NULL
*************************** 2. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:4:4:2138303895576
ENGINE_TRANSACTION_ID: 1424
            THREAD_ID: 56
             EVENT_ID: 775
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: PRIMARY
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X
          LOCK_STATUS: GRANTED
            LOCK_DATA: 12
*************************** 3. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:4:5:2138303895576
ENGINE_TRANSACTION_ID: 1424
            THREAD_ID: 56
             EVENT_ID: 775
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: PRIMARY
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X
          LOCK_STATUS: GRANTED
            LOCK_DATA: 18

可以看到除有表级的意向排它锁（IX）,还加了id=12和id=18这两行数据的临键锁。
加锁过程：1：在主键索引上查找id>7的数据；
2：找到id=12这条数据，获取其临键锁；
3：范围查询，继续查找，依次获取所访问到行的临键锁，直至第一个大于等于where条件里面上限值的值，本例中就是id=18。
思考： 如果条件换成id>7 and id<=20 或id>=7 and id<20会如何呢？
这里先列出答案，不做分析，结论如下：
当 id>7 and id<18时会获取id=12的临键锁和id=18的间隙锁；
当 id>7 and id<=20时会获取id=12,18的临键锁和id=23的间隙锁；
当 id>=7 and id<20时会获取id=7的记录锁，id=12,18的临键锁和id=23的间隙锁；

2.唯一索引

唯一索引加锁规则几乎与主键索引相同，差别之处请往下看

1：select * from test where key_id=18 for update;

查询数据存在。

mysql> select * from performance_schema.data_locks\G;
*************************** 1. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:1064:2138320015896
ENGINE_TRANSACTION_ID: 1426
            THREAD_ID: 56
             EVENT_ID: 819
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: NULL
OBJECT_INSTANCE_BEGIN: 2138320015896
            LOCK_TYPE: TABLE
            LOCK_MODE: IX
          LOCK_STATUS: GRANTED
            LOCK_DATA: NULL
*************************** 2. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:5:5:2138303895576
ENGINE_TRANSACTION_ID: 1426
            THREAD_ID: 56
             EVENT_ID: 819
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: ind_key
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X,REC_NOT_GAP
          LOCK_STATUS: GRANTED
            LOCK_DATA: 18, 18
*************************** 3. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:4:5:2138303895920
ENGINE_TRANSACTION_ID: 1426
            THREAD_ID: 56
             EVENT_ID: 819
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: PRIMARY
OBJECT_INSTANCE_BEGIN: 2138303895920
            LOCK_TYPE: RECORD
            LOCK_MODE: X,REC_NOT_GAP
          LOCK_STATUS: GRANTED
            LOCK_DATA: 18

可以看到除有表级的意向排它锁（IX）,还加了id=18这行数据的记录锁锁和key_id=18的记录锁，所以对于非主键索引来说，除了获取自身的行锁，还会获取所访问行的主键的记录锁。
PS:根据LOCK_DATA字段的值18,18可知，对于非主键索引，其范围表示还要加上主键值
则临键锁有：(负无穷,(5,5)]，((5,5),(7,7)]…((31,31),(49,42)],((49,42),正无穷),
即按非主键索引排序

2：select * from test where key_id=20 for update;

查询数据不存在。

mysql> select * from performance_schema.data_locks\G;
*************************** 1. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:1064:2138320015896
ENGINE_TRANSACTION_ID: 1427
            THREAD_ID: 56
             EVENT_ID: 841
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: NULL
OBJECT_INSTANCE_BEGIN: 2138320015896
            LOCK_TYPE: TABLE
            LOCK_MODE: IX
          LOCK_STATUS: GRANTED
            LOCK_DATA: NULL
*************************** 2. row ***************************
               ENGINE: INNODB
       ENGINE_LOCK_ID: 2138314382288:2:5:6:2138303895576
ENGINE_TRANSACTION_ID: 1427
            THREAD_ID: 56
             EVENT_ID: 841
        OBJECT_SCHEMA: test
          OBJECT_NAME: test
       PARTITION_NAME: NULL
    SUBPARTITION_NAME: NULL
           INDEX_NAME: ind_key
OBJECT_INSTANCE_BEGIN: 2138303895576
            LOCK_TYPE: RECORD
            LOCK_MODE: X,GAP
          LOCK_STATUS: GRANTED
            LOCK_DATA: 23, 23

可以看到除有表级的意向排它锁（IX）,还加了key_id=23的间隙锁，因为查询结果为空，所以不会存在所访问行主键的记录锁。

3：select * from test where key_id >7 and key_id<17 for update;

范围查询。

mysql> select ENGINE_LOCK_ID,INDEX_NAME, LOCK_TYPE,LOCK_MODE, LOCK_STATUS, LOCK_DATA from performance_schema.data_locks;
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| ENGINE_LOCK_ID                    | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| 2138314382288:1064:2138320015896  | NULL       | TABLE     | IX            | GRANTED     | NULL      |
| 2138314382288:2:5:4:2138303895576 | ind_key    | RECORD    | X             | GRANTED     | 12, 12    |
| 2138314382288:2:5:5:2138303895576 | ind_key    | RECORD    | X             | GRANTED     | 18, 18    |
| 2138314382288:2:4:4:2138303895920 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 12        |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+

可以看到除有表级的意向排它锁（IX）,还加了key_id=12,18的临键锁，以及所访问到的主键id=12的记录锁。

PS:这里注意下为何key_id=18的临键锁没有被优化成间隙锁可以说是MySQL加锁的一个bug，非主键唯一索引在范围查询的时候并没有做优化，和普通索引一样。
如果条件换成key_id >=7 and key_id<=18会有不一样的bug,因为此时会获得key_id=7,12,18,23的临键锁，正常来说应该是key_id=7的记录锁，key_id=12,18的临键锁的，其并没有按主键的加锁规则来优化。

将非主键唯一索引的范围查询和普通索引的范围查询的加锁作对比，发现其加锁规则一模一样。

3.普通索引

1：select * from test where num = 12 for update;

查询数据存在。

mysql> select ENGINE_LOCK_ID,INDEX_NAME, LOCK_TYPE,LOCK_MODE, LOCK_STATUS, LOCK_DATA from performance_schema.data_locks;
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| ENGINE_LOCK_ID                    | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| 2138314382288:1064:2138320015896  | NULL       | TABLE     | IX            | GRANTED     | NULL      |
| 2138314382288:2:6:4:2138303895576 | ind_num    | RECORD    | X             | GRANTED     | 12, 12    |
| 2138314382288:2:6:5:2138303895576 | ind_num    | RECORD    | X             | GRANTED     | 12, 18    |
| 2138314382288:2:4:4:2138303895920 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 12        |
| 2138314382288:2:4:5:2138303895920 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 18        |
| 2138314382288:2:6:6:2138303896264 | ind_num    | RECORD    | X,GAP         | GRANTED     | 22, 23    |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+

可以看到除了获的表级的意向排它锁（IX）,还获取两条num=12的临键锁，以及第一个大于12的num值的间隙锁，即num=22,id=23,并不会去获取num=22,id=24的间隙锁。
加锁过程：1：找到num=12的第一条数据，获取其临键锁，以及对应id=12的记录锁；
2：继续向下查找，访问到的行都获取其临键锁以及对应主键的记录锁；
3：直至找到第一个num大于12的行，获取其间隙锁，结束。

2：select * from test where num = 18 for update;

查询数据不存在。

mysql> select ENGINE_LOCK_ID,INDEX_NAME, LOCK_TYPE,LOCK_MODE, LOCK_STATUS, LOCK_DATA from performance_schema.data_locks;
+-----------------------------------+------------+-----------+-----------+-------------+-----------+
| ENGINE_LOCK_ID                    | INDEX_NAME | LOCK_TYPE | LOCK_MODE | LOCK_STATUS | LOCK_DATA |
+-----------------------------------+------------+-----------+-----------+-------------+-----------+
| 2138314382288:1064:2138320015896  | NULL       | TABLE     | IX        | GRANTED     | NULL      |
| 2138314382288:2:6:6:2138303895576 | ind_num    | RECORD    | X,GAP     | GRANTED     | 22, 23    |
+-----------------------------------+------------+-----------+-----------+-------------+-----------+

可以看到除了获的表级的意向排它锁（IX）,还获取了第一个大于18的num值的间隙锁，即num=22,id=23。
加锁过程：1：找到num=18的第一条数据，找不到；
2：继续向下查找，直至找到第一个num大于18的行，获取其间隙锁，结束。

3：select * from test where num >7 and num <17 for update;

查询范围。

mysql> select ENGINE_LOCK_ID,INDEX_NAME, LOCK_TYPE,LOCK_MODE, LOCK_STATUS, LOCK_DATA from performance_schema.data_locks;
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| ENGINE_LOCK_ID                    | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+
| 2138314382288:1064:2138320015896  | NULL       | TABLE     | IX            | GRANTED     | NULL      |
| 2138314382288:2:6:4:2138303895576 | ind_num    | RECORD    | X             | GRANTED     | 12, 12    |
| 2138314382288:2:6:5:2138303895576 | ind_num    | RECORD    | X             | GRANTED     | 12, 18    |
| 2138314382288:2:6:6:2138303895576 | ind_num    | RECORD    | X             | GRANTED     | 22, 23    |
| 2138314382288:2:4:4:2138303895920 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 12        |
| 2138314382288:2:4:5:2138303895920 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 18        |
+-----------------------------------+------------+-----------+---------------+-------------+-----------+

可以看到除了获的表级的意向排它锁（IX）,还获取了num=12，22的临键锁，以及所访问的行主键id=12,18的记录锁。
加锁过程：1：找到第一个num大于7的行，获取其临键锁（num=12,id=12），以及对应id=12的记录锁；
2：继续向下查找，访问到的行都获取其临键锁以及对应主键的记录锁；
3：直至找到第一个num大于等于17的行，获取其临键锁（num=22,id=23），结束。
4:最终锁定范围是((7,7),(22,23)]
因为普通索引的值是可以重复的，所以此时对于num=7,id<7和num=22,id>23这样的边缘值是可以正常插入的
思考1：如何查询条件是num >7 and num <=22 会如何？？
区别在第三步，直至找到第一个num大于22的行，获取其临键锁，结束。

思考2：为何找到第一个num大于等于17的行，获取其临键锁而不是间隙锁？？
？？猜测是因为普通索引的值是可重复的，貌似也不能自圆其说，有时间看看源码吧

总结

通过前面的分析可以得出，加锁有以下规则：

  1. 加锁的基本单位是临键锁，要注意主键和非主键的临键锁范围表示不同，主键（id1,id2],非主键（(key1,id1),(key2,id2)]；
  2. 对于非主键，除了获取自身的临键锁，还会获取访问到的行的主键的记录锁；
  3. 对于唯一索引，等值查询，存在时临键锁会被优化成记录锁，不存在时向下遍历第一个不等于的值获取其临键锁，并会被优化成间隙锁；
  4. 对于普通索引，等值查询，除了获取等值的临键锁，还会向下遍历到第一个不等于的值获取其临键锁，不过会被优化成间隙锁，不存在时向下遍历第一个不等于的值获取其临键锁，并会被优化成间隙锁；
  5. 对于主键索引，范围查询遵循唯一索引等值查询的优化规则；
  6. 对于非主键唯一索引和普通索引，范围查询遵循普通索引等值查询的优化规则；
  7. 非主键唯一索引范围查询是有bug的，见MySQL45讲
pigfu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL中InnoDB的间隙锁问题
09-10
主要介绍了MySQL中InnoDB的间隙锁问题,提醒用户注意死锁情况,需要的朋友可以参考下
MySQL InnoDB中的锁机制深入讲解
09-09
InnoDB的Next-Key Lock实际上是结合了记录锁和间隙锁，锁定当前记录并防止在相邻间隙中插入记录。 以下是一个例子，展示了如何在不同场景下使用和应用这些锁： - 如果事务A对name为1的记录加锁，那么name为1的记录...
【锁】MySQL间隙锁
coco3600的博客
08-03 260
【锁】MySQL间隙锁 前段时间系统老是出现insert死锁，很是纠结。经过排查发现是间隙锁！间隙锁是innodb中行锁的一种， 但是这种锁锁住的却不止一行数据，他锁住的是多行，是一个数据范围。间隙锁的主要...
Mysql间隙锁实战
代码缔造者的博客
05-01 1047
前言 本次实战是基于数据库mysql5.7.14 什么是间隙锁？ 间隙锁是对索引记录之间间隙的锁，或者对第一个索引记录之前或最后一个索引记录之后的间隙的锁。例如:SELECT c1 FROM t WHERE c1 BETWEEN 10 and 20 For UPDATE;防止其他事务向列t.c1插入值15，无论列中是否已经有这样的值，因为范围内所有现有值之间的差距是锁定的。 什么时候会使用间隙锁？ InnoDB 存储引擎隔离级别是RR前提下同时有事务发生。 间隙锁有什么作用？ 首先有个前提是知
Mysql锁-间隙锁实战
qq_35519587的博客
05-10 830
间隙锁规则: 两个“原则”、两个“优化”和一个“bug”: 1.加锁的基本单位是next-key lock，next-key lock是前开后闭区间。 2.查找过程中访问到的对象才会加锁。 3.索引上的等值查询，给唯一索引加锁的时候，next-key lock退化为行锁。 4.索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock退化为间隙锁。 5.唯一索引上的范围查询会访问到不满足条件的第一个值为止。 规则前提说明： MySQL后面的版本可能会改变加锁策略，所以这个规则只
Mysql 行锁（记录锁、间隙锁、临键锁）研究，基于InnoDB
weixin_38597669的博客
04-22 6258
本文主要针对InnoDB的行锁研究，避免陷入间隙锁而导致死锁等不利现象。
MySQL的锁机制——记录锁、间隙锁、临键锁
最新发布
m0_51431003的博客
03-09 3512
当我们使用索引，无论是等值还是范围查询，没有命中一条记录时候，加的就是间隙锁。我们在表中插入4条记录，主键分别是1、4、7、10。图中的范围区间就会被锁住，都是左开右开的区间。
MySQL中InnoDB锁的介绍及用途
01-19
读这篇文章之前可以先了解一下MySQL中InnoDB数据结构 一、InnoDB引擎对隔离级别的支持 事务隔离级别 脏读 不可重复读 幻读 读未提交（read-uncommitted） 可能 可能 可能 不可重复读（read-committed） 不...
MySQL锁(表锁,行锁,共享锁,排它锁,间隙锁)使用详解
01-19
锁，在现实生活中是为我们想要隐藏...相对于其他的数据库而言，MySQL的锁机制比较简单，最显著的特点就是不同的存储引擎支持不同的锁机制。根据不同的存储引擎，MySQL中锁的特性可以大致归纳如下： 行锁 表锁 页锁
【MySQL】 MySQL间隙锁理解
我还可以
08-12 905
间隙锁(Gap Lock)是Innodb在可重复读提交下为了解决幻读问题时引入的锁机制，间隙锁只有在隔离级别为可重复读的情况下才会生效；锁加载两个索引之间（空闲空间），也可以是第一个索引之前，也有可能是最后一个索引之后；事务 A 按照一定条件进行数据读取， 期间事务 B 插入了相同搜索条件的新数据，事务 A 再次按照原先条件进行读取时，发现了事务 B 新插入的数据，这种现象称为幻读；...
MySQL死锁 预防分析解决死锁
AllenChan_的博客
08-16 1250
​本篇文章根据官网文档的例子，学习死锁是如何发生的，以及如何预防和解决死锁。 死锁发生的例子 MySQL的死锁检测 降低和处理死锁
MySQL中间隙锁的加锁机制
程序猿集锦的博客
12-14 3375
微信搜索“coder-home”或扫一扫下面的二维码，关注公众号，第一时间了解更多干货分享，还有各类视频教程资源。扫描它，带走我 文章目录背景实验环境的准备前置条件准备建表语句准备初始化数据最后的测试环境间隙锁的结构索引的结构间隙锁加锁规则实验部分RR级别+主键索引列RR级别+唯一索引列RR级别+非唯一索引列RR级别+普通字段列总结 背景 间隙锁是MySQL在RR可重复读隔离级别下用来修复幻读才引入的一种锁，间隙锁也只有在RR可重复读隔离级别下才会存在，如果是在RC读已提交隔离级别下，是没有间隙锁的存.
mysql_间隙锁_实验——for update
一个搬砖工人
10-09 626
select * from tb_lock where id 5 for update；
mysql之间隙锁
qq_41820066的博客
11-14 545
MySQL之间隙锁
【MySQL】MySQL的锁机制 - 记录锁、间隙锁、临键锁
sfh2018的博客
10-28 5425
MySQL的锁机制 - 记录锁、间隙锁、临键锁
mysql的行锁和间隙锁
qq_38205881的博客
07-31 1646
无论是update还是select for update，只要where条件里面字段没有带索引，都会把整个表锁住。如果更新的行上存在索引，更新时锁定被更新的记录。
心灵拷问：MySQL 到底是怎么加行级锁、间隙锁、临键锁的？
祝我飞黄腾达
04-13 4703
Next-Key Lock 是一张间隙锁，相较于行锁只锁定一行，它会锁定一个区间范围，加锁的范围区间内的索引键值会被锁定 MySQL InnoDB支持三种行锁定方式 InnoDB的默认加锁方式是next-key。如某个加锁操作未使用到索引，则该锁会退化为表锁。 行锁 (Record Lock)：存在唯一索引中 (包含主键索引)，锁定单条索引记录，即key。 间隙锁 (Gap Lock)：存在非唯一索引中，锁定索引记录间隙，确保索引记录的间隙不变。 临键锁 (Next-Key Lo.
MySQL间隙锁问题
追梦人的博客
01-03 8505
间隙锁（Gap Lock）：锁加在不存在的空闲空间，可以是两个索引记录之间，也可能是第一个索引记录之前或最后一个索引之后的空间。 最近用户反馈说系统老是出现insert时，等待超时了，最后发现是insert间隙锁！间隙锁是innodb中行锁的一种， 但是这种锁锁住的却不止一行数据，他锁住的是多行，是一个数据范围。间隙锁的主要作用是为了防止出现幻读，但是它会把锁定范围扩大，有时候也会给我们带来麻烦
mysql间隙锁_mysql的间隙锁
weixin_42571476的博客
01-18 655
最近学习了mysql的各种锁，有点晕，打算通过文章的方式捋一捋。在学习了mvcc后，我就想，他已经很好的解决了并发读写了，但我也知道innodb提供了多种类型的锁，所以很好奇这些锁有什么用，为什么这些锁的功能是mvcc做不到的？(本文讨论的都是rr级别下的锁)我先创建一个表，并插入几行数据，如下图：插入内容如下：c字段加了普通索引，d字段无索引。此时，开启session a，开始一个事务，搜索d=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值