MySQL锁

一条update语句

  1. # 创建表结构
  2. CREATE TABLE t ( 
  3.     id INT PRIMARY KEY,
  4.     name VARCHAR(100) 
  5. ) Engine=InnoDB CHARSET=utf8;
  7. # 插入一条记录
  8. INSERT INTO `test`.`t`(`id`, `name`) VALUES (1, 'GC');
  10. # 对这条记录进行修改
  11. UPDATE `test`.`t` SET `name` = 'XA' WHERE `id` = 1;

执行流程：

MySQL锁 - 图1

MySQL中的锁介绍

在MySQL中锁总共分为三大类：

  • 全局锁：锁住整个数据库（database）
  • 表级锁：锁住整张表（table）
  • 行级锁：锁住表中具体的行（row）

按照锁的功能来说分为：共享锁和排他锁。

  • 共享锁（S）：加了共享锁后，允许其它事物继续在当前行上继续加S锁，不允许加X锁。加锁方式：select…lock in share mode
  • 排它锁（X）：加了排它锁后，不允许其它锁对该行数据加任何其它所，其它事物若想对当前行加锁，只能等待当前事物释放锁。加锁方式：select…for update | 锁类型 | 共享锁S | 排它锁X | | :—-: | :—-: | :—-: | | 共享锁 S | 兼容 | 冲突 | | 排他锁 X | 冲突 | 冲突 |

全局锁

  1. 全局锁就对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的MDL的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性。
  1. # 全局锁加锁
  2. flush tables with read lock;
  4. #释放全局锁
  5. unlock tables；

或者断开加锁session的连接，自动释放全局锁。

  1. 另外，全局锁用于备份这个事情，还是很危险的。因为如果在主库上加全局锁，则整个数据库将不能写入，备份期间影响业务运行，如果在从库上加全局锁，则会导致不能执行主库同步过来的操作，造成主从延迟。

表级锁

MySQL的表级锁有四种：

  1. 表读、写锁
  2. 元数据锁（meta data lock，MDL)
  3. 意向锁 Intention Locks（InnoDB）
  4. 自增锁(AUTO-INC Locks)

查看表锁相关命令：

  1. # MySQL 实现的表级锁定的争用状态变量
  2. show status like 'table%';
  5. - table_locks_immediate：产生表级锁定的次数
  6. - table_locks_waited   ：出现表级锁定争用而发生等待的次数

MySQL锁 - 图2

表锁测试

环境准备

  1. CREATE TABLE `mylock`  (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,
  3.   `NAME` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  4.   PRIMARY KEY (`id`) USING BTREE
  5. ) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
  8. INSERT INTO `mylock` VALUES (1, 'Lock1');
  9. INSERT INTO `mylock` VALUES (2, 'Lock2');
  10. INSERT INTO `mylock` VALUES (3, 'Lock3');
  11. INSERT INTO `mylock` VALUES (4, 'Lock4');
  12. INSERT INTO `mylock` VALUES (5, 'Lock5');

读锁测试：

MySQL锁 - 图3

写锁测试：

MySQL锁 - 图4

元数据锁

  1. MDL是在MySQL5.5版本引入的，MDL元数据锁不需要我们用户干预，在访问一个表的时候会被自动加上。MDL的作用是，保证读写的正确性。其实用于在对表结构进行修改的时候对表进行锁定，防止在另外一个事物里重复读的时候出现数据结构不一致的情况。
  3. 在对表进行 增删改查的时候会加MDL读锁，在对表结构进行修改的时候会加MDL写锁。

元数据锁演示

MySQL锁 - 图5

意向锁

  1. InnoDB也实现了表级锁，也就是意向锁，它是页不需要用户干预的，意向锁和行锁可以共存。
  3. 意向锁的主要作用是为了【全表更新数据】时的性能提升。否则在全表更新数据时，需要先检索该表是否某些记录上面有行锁。
  1. 表明“某个事务正在某些行持有了锁、或该事务准备去持有锁”
  2. 意向锁的存在是为了协调行锁和表锁的关系，支持多粒度（表锁与行锁）的锁并存。
  3. 例子：事务A修改user表的记录r，会给记录r上一把行级的排他锁（X），同时会给user表会上一把意向排它锁（IX），这时事物B如果想给user表加表锁就会被阻塞，意向锁通过这种方式实现了表锁与行锁直接共存而且满足事物的隔离级别。
  4. 共享意向锁（IS）：事物在加S锁前，要先获得IS锁。
  5. 排他意向锁（IX）：事物在加X锁前，要先获得IX锁。

意向锁的作用

  1. 在对表要进行加排它锁时，需要根据意向锁去判断表中有没有数据行被锁定（行锁）。如果表被判定有意向锁，则就知道该表当前存在行锁。

否则要遍历表中的行才知道该表有没有行锁。

意向锁和共享锁、排他锁的兼容关系

锁类型 共享锁 S 排他锁 X 意向共享锁 IS 意向排他锁 IX
共享锁 S 兼容 冲突 兼容 冲突
排他锁 X 冲突 冲突 冲突 冲突
意向共享锁 IS 兼容 冲突 兼容 兼容
兼容意向排他锁 IX 冲突 冲突 兼容 兼容

InnoDB 表存在两种表级锁，一种是LOCK TABLES语句手动指定的锁，另一种是由 InnoDB 自动添加的意向锁。

简单来说，意向锁和表锁之间只有共享锁兼容，意向锁和意向锁之间都可以兼容。意向锁的主要作用是表明某个事务正在或者即将锁定表中的数据行。

行级锁

  1. MySQL的**行级锁**，是由**存储引擎**来实现的，这里我们说的是**InnoDB**的行级锁。
  3. **InnoDB**行锁**是通过给索引上的**索引项加锁来实现的，因此InnoDB这种行锁实现特点意味着：只有通过索引条件检索的数据，InnoDB才使用行级锁，否则InnoDB将使用表锁。总的来说在InnoDB中行锁分为四种：
  • 记录锁（Record Locks）:锁定索引中一条记录。
  • 间隙锁（Gap Locks）:要么锁住索引记录中间的值，要么锁住第一个索引记录前面的值或者最后一个索引记 录后面的值。
  • 临键锁（Next-Key Locks）:是索引记录上的记录锁和在索引记录之前的间隙锁的组合（间隙锁+记录 锁）。

  • 插入意向锁(Insert Intention Locks)：做insert操作时添加的对记录id的锁。

    InnoDB的行级锁，按照功能来说，分为两种：

  • 共享锁（S）：允许一个事务去读一行，阻止其他事务获得相同数据集的排他锁。

  • 排他锁（X）：允许获得排他锁的事务更新数据，阻止其他事务取得相同数据集的共享读锁和排他写锁。

对于UPDATE、DELETE和INSERT语句，InnoDB会自动给涉及数据集加排他锁（X)；对于普通SELECT语句，InnoDB不会加任何锁，事务可以通过以下语句显示给记录集加共享锁或排他锁。

  1. # 手动添加共享锁（S）：
  2. SELECT * FROM table_name WHERE ... LOCK IN SHARE MODE
  4. # 手动添加排他锁（x）：
  5. SELECT * FROM table_name WHERE ... FOR UPDATE

记录锁(Record Locks)

记录锁测试：

当查询的列上没有索引, 对查询语句加排他锁测试，看会不会造成锁表的情况：

可以看到session1中的测试结果，当前事物加排它锁，不影响当前事物操作增删改查。

  1. # session1
  2. mysql> begin;
  3. Query OK, 0 rows affected (0.00 sec)
  5. # 可以查询
  6. mysql> select * from mylock where NAME = 'Lock1' for update;
  7. +----+-------+
  8. | id | NAME  |
  9. +----+-------+
  10. |  1 | Lock1 |
  11. +----+-------+
  12. 1 row in set (0.02 sec)
  14. # 可以新增
  15. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (100, 'Lock100');
  16. Query OK, 1 row affected (0.00 sec)
  18. # 可以修改
  19. mysql> UPDATE `mylock` SET `NAME` = 'Lock1' WHERE `id` = 1;
  20. Query OK, 0 rows affected (0.00 sec)
  21. Rows matched: 1  Changed: 0  Warnings: 0
  23. # 可以删除
  24. mysql> delete from mylock where id = 1;
  25. Query OK, 1 row affected (0.00 sec)
  27. # 查看当前是否有被锁住的表
  28. # 可以看到当前mylock已经是锁表的状态
  29. mysql> show OPEN TABLES where In_use > 0;
  30. +----------+--------+--------+-------------+
  31. | Database | Table  | In_use | Name_locked |
  32. +----------+--------+--------+-------------+
  33. | test     | mylock |      1 |           0 |
  34. +----------+--------+--------+-------------+
  35. 1 row in set (0.05 sec)
  38. # 查看正在锁的事物
  39. mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;
  40. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+------------------------+
  41. | lock_id            | lock_trx_id | lock_mode | lock_type | lock_table      | lock_index | lock_space | lock_page | lock_rec | lock_data              |
  42. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+------------------------+
  43. | 193375534:8104:3:1 | 193375534   | X         | RECORD    | `test`.`mylock` | PRIMARY    |       8104 |         3 |        1 | supremum pseudo-record |
  44. 2 rows in set (0.07 sec)
  46. mysql> rollback;
  47. Query OK, 0 rows affected (0.00 sec)

而在session2中，除了可以查询，其它的操作都不能做，这无疑是因为session1中的家了排他锁，而该列上又没有索引而导致了锁表的情况

  1. # session2
  2. mysql> begin;
  3. Query OK, 0 rows affected (0.00 sec)
  5. # 可以查询
  6. mysql> select * from mylock where NAME = 'LOCK1';
  7. +----+-------+
  8. | id | NAME  |
  9. +----+-------+
  10. |  1 | Lock1 |
  11. +----+-------+
  12. 1 row in set (0.01 sec)
  14. # 新增阻塞
  15. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (100, 'Lock100');
  17. # 修改阻塞
  18. mysql> UPDATE `mylock` SET `NAME` = 'Lock1' WHERE `id` = 1;
  20. # 删除阻塞
  21. mysql> delete from mylock where id = 1;
  23. mysql> rollback;
  24. Query OK, 0 rows affected (0.00 sec)

接下来，我们给 NAME字段加上唯一索引再来进行测试

  1. # 增加唯一索引
  2. alter table `mylock` add unique  (`NAME` )

进行测试

  1. # session1
  2. mysql> begin;
  3. Query OK, 0 rows affected (0.00 sec)
  5. # 给 NAME = 'LOCK1'd的数据加排它锁
  6. mysql> select * from mylock where NAME = 'LOCK1' for update;
  7. +----+-------+
  8. | id | NAME  |
  9. +----+-------+
  10. |  1 | Lock1 |
  11. +----+-------+
  12. 1 row in set (0.02 sec)
  15. mysql> rollback;
  16. Query OK, 0 rows affected (0.00 sec)
  1. # session2
  3. # 开启事务
  4. mysql> being;
  5. mysql> begin;
  6. Query OK, 0 rows affected (0.00 sec)
  8. # 能查询session1加排它锁的数据
  9. mysql> select * from mylock where NAME = 'LOCK1';
  10. +----+-------+
  11. | id | NAME  |
  12. +----+-------+
  13. |  1 | Lock1 |
  14. +----+-------+
  15. 1 row in set (0.05 sec)
  17. # 能查询表中其它数据
  18. mysql> select * from mylock where NAME = 'LOCK2';
  19. +----+-------+
  20. | id | NAME  |
  21. +----+-------+
  22. |  2 | Lock2 |
  23. +----+-------+
  24. 1 row in set (0.04 sec)
  26. # 能新增数据到mylock表中
  27. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (101, 'Lock101');
  28. Query OK, 1 row affected (0.00 sec)
  30. # 能删除mylock表中的数据
  31. mysql> DELETE FROM  mylock WHERE ID = 10;
  32. Query OK, 1 row affected (0.00 sec)
  34. # 能修改mylock中的数据
  35. mysql> UPDATE `mylock` SET `NAME` = 'Lock3UP' WHERE `id` = 3;
  36. Query OK, 1 row affected (0.00 sec)
  38. # 修改session1中加锁的记录行,则会阻塞
  39. mysql> UPDATE `mylock` SET `NAME` = 'Lock3UP' WHERE `id` = 3;
  41. mysql> rollback;
  42. Query OK, 0 rows affected (0.00 sec)
  1. 由此证实，在没有索引的列上进行查询时，如果加了**for update**排它锁，则会进行锁表操作，如果有索引，则只会对当前一行记录加锁。所以在开发中要谨慎使用锁相关的操作。

间隙锁(Gap Locks)

  1. 间隙锁 锁定的是索引记录之间的间隙、第一个索引之前的间隙或者最后一个索引之后的间隙。例如: <font color='red'>SELECT * FROM mylock WHERE id BETWEEN 1 and 10 FOR UPDATE;</font>会阻止其他事务将 1 到 10 之间的任何值插入到 c1 字段中，即使该列不存在这样的数据；因为这些值都会被锁定。

MySQL锁 - 图6

  1. # 在做测试之前,因为我们上面刚才给 ‘NAME’ 字段加了唯一索引。先删除掉
  2. # 不然如果使用select * 的话就会产生锁表的情况,即使我们的where 是id,但是 'NAME' 仍然带着唯一索引存在 select * 中。
  3. drop index name on mylock

通过主键操作范围值

  1. # session1
  2. mysql> begin;
  3. Query OK, 0 rows affected (0.00 sec)
  5. # 锁住 id 1 - 10之间的记录
  6. mysql> select * from mylock where id between 1 and 10 for update;
  7. +----+--------+
  8. | id | NAME   |
  9. +----+--------+
  10. |  1 | Lock1  |
  11. |  6 | Lock6  |
  12. |  7 | Lock7  |
  13. | 10 | Lock10 |
  14. +----+--------+
  15. 4 rows in set (0.02 sec)
  18. mysql> rollback;
  19. Query OK, 0 rows affected (0.00 sec)
  1. # session2
  3. mysql> begin;
  4. Query OK, 0 rows affected (0.00 sec)
  6. # 查询
  7. mysql> select * from mylock;
  8. +----+--------+
  9. | id | NAME   |
  10. +----+--------+
  11. |  1 | Lock1  |
  12. |  6 | Lock6  |
  13. |  7 | Lock7  |
  14. | 10 | Lock10 |
  15. +----+--------+
  16. 4 rows in set (0.02 sec)
  18. # 新增阻塞
  19. # 虽然mylock表里只有4条记录,而id=2的数据当前不存在mylock表中,间隙锁锁的是一个区间,所以当在执行id=2的新增的操作时,也是会被锁住的
  20. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (2, 'Lock2');
  21. 1205 - Lock wait timeout exceeded; try restarting transaction
  24. # 但是,我们可以插入id > 10的数据,是没有问题的。因为这类数据不再session1间隙锁的范围中
  25. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (17, 'Lock17');
  26. Query OK, 1 row affected (0.00 sec)
  29. mysql> rollback;
  30. Query OK, 0 rows affected (0.00 sec)

接来来我们来试一下，如果锁的是记录不存在的等值查询，会发生什么

  1. # session1
  2. mysql> begin;
  3. Query OK, 0 rows affected (0.00 sec)
  5. # 看一下表中的数据
  6. mysql> select * from mylock;
  7. +----+--------+
  8. | id | NAME   |
  9. +----+--------+
  10. |  1 | Lock1  |
  11. |  6 | Lock6  |
  12. |  7 | Lock7  |
  13. | 10 | Lock10 |
  14. +----+--------+
  15. 4 rows in set (0.04 sec)
  17. # 等值=9的排它锁
  18. mysql> select * from mylock where id = 9 for update;
  19. Empty set
  21. # 通过执行锁信息语句可以看到,当前被加了排它锁+间隙锁,所以导致session2插入id=8的数据会被阻塞
  22. mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;
  23. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+-----------+
  24. | lock_id            | lock_trx_id | lock_mode | lock_type | lock_table      | lock_index | lock_space | lock_page | lock_rec | lock_data |
  25. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+-----------+
  26. | 194106112:8104:3:9 | 194106112   | X,GAP     | RECORD    | `test`.`mylock` | PRIMARY    |       8104 |         3 |        9 | NULL      |
  27. | 194105929:8104:3:9 | 194105929   | X,GAP     | RECORD    | `test`.`mylock` | PRIMARY    |       8104 |         3 |        9 | NULL      |
  28. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+-----------+
  29. 2 rows in set (0.04 sec)
  31. mysql> rollback;
  32. Query OK, 0 rows affected (0.00 sec)
  1. # session2
  3. mysql> begin;
  4. Query OK, 0 rows affected (0.00 sec)
  6. # 阻塞
  7. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (8, 'Lock8');
  9. # 成功,因为id=12的记录不存在于表记录中,间隙锁的最大值是10,所以插入id=12的数据不会被阻塞
  10. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (12, 'Lock12');
  11. Query OK, 1 row affected (0.00 sec)
  13. mysql> rollback;
  14. Query OK, 0 rows affected (0.00 sec)

接下来我们继续测试一个主键大于当前表中所有的数据

  1. # session1
  4. mysql> begin;
  5. Query OK, 0 rows affected (0.00 sec)
  7. mysql> select * from mylock;
  8. +----+--------+
  9. | id | NAME   |
  10. +----+--------+
  11. |  1 | Lock1  |
  12. |  6 | Lock6  |
  13. |  7 | Lock7  |
  14. | 10 | Lock10 |
  15. +----+--------+
  16. 4 rows in set (0.03 sec)
  18. # 锁住一个不存在的主键
  19. mysql> select * from mylock where id = 30 for update;
  20. Empty set
  22. # 查看锁信息,可以看到当前mylock表锁的类型是X, 锁的数据是supremum pseudo-record
  23. # 当N超过表里的最大值时，两种方式都会对primary索引的 supremum pseudo-record加一个 X锁，导致其他的insert会被阻塞
  24. # supremum pseudo-record :相当于比索引中所有值都大，但却不存在索引中，相当于最后一行之后的间隙锁
  25. mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;
  26. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+------------------------+
  27. | lock_id            | lock_trx_id | lock_mode | lock_type | lock_table      | lock_index | lock_space | lock_page | lock_rec | lock_data              |
  28. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+------------------------+
  29. | 194108389:8104:3:1 | 194108389   | X         | RECORD    | `test`.`mylock` | PRIMARY    |       8104 |         3 |        1 | supremum pseudo-record |
  30. | 194107672:8104:3:1 | 194107672   | X         | RECORD    | `test`.`mylock` | PRIMARY    |       8104 |         3 |        1 | supremum pseudo-record |
  31. +--------------------+-------------+-----------+-----------+-----------------+------------+------------+-----------+----------+------------------------+
  32. 2 rows in set (0.04 sec)
  34. mysql> rollback;
  35. Query OK, 0 rows affected (0.00 sec)
  1. # session2
  3. mysql> begin;
  4. Query OK, 0 rows affected (0.00 sec)
  6. # 插入id=14的数据, 当前数据 < 30 
  7. # 阻塞
  8. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (14, 'Lock14');
  10. # 插入id=40的数据, 当前数据 > 30 
  11. # 阻塞
  12. mysql> INSERT INTO `test`.`mylock`(`id`, `NAME`) VALUES (40, 'Lock40');
  14. mysql> rollback;
  15. Query OK, 0 rows affected (0.00 sec)

临键锁(Next-Key Locks)

  • record lock + gap lock, 左开右闭区间，例如（5,8]。

  • 默认情况下，innodb使用next-key locks来锁定记录。select … for update

  • 但当查询的索引含有唯一属性的时候，Next-Key Lock 会进行优化，将其降级为Record Lock，即

  • 仅锁住索引本身，不是范围。
    Next-Key Lock在不同的场景中会退化:

场景 退化成的锁类型
使用unique index精确匹配（=），且记录存在 Record Lock
使用unique index精确匹配（=），且记录不存在 Gap Lock
使用unique index范围匹配（ <和> ） Record Lock + Gap Lock 
  1. # 测试环境准备
  3. CREATE TABLE `t1_simple`  (
  4.   `id` int(11) NOT NULL AUTO_INCREMENT,
  5.   `pubtime` int(11) NULL DEFAULT NULL,
  6.   PRIMARY KEY (`id`) USING BTREE,
  7.   INDEX `pubtime_index`(`pubtime`) USING BTREE
  8. ) ENGINE = InnoDB AUTO_INCREMENT = 121 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
  10. -- ----------------------------
  11. -- Records of t1_simple
  12. -- ----------------------------
  13. INSERT INTO `t1_simple` VALUES (10, 1);
  14. INSERT INTO `t1_simple` VALUES (13, 1);
  15. INSERT INTO `t1_simple` VALUES (4, 3);
  16. INSERT INTO `t1_simple` VALUES (11, 4);
  17. INSERT INTO `t1_simple` VALUES (8, 5);
  18. INSERT INTO `t1_simple` VALUES (12, 9);
  19. INSERT INTO `t1_simple` VALUES (1, 10);
  20. INSERT INTO `t1_simple` VALUES (100, 20);
  21. INSERT INTO `t1_simple` VALUES (6, 100);
  1. # session1
  3. mysql> begin;
  4. Query OK, 0 rows affected (0.00 sec)
  6. # 对pubtime=20的记录加X锁
  7. mysql> select * from t1_simple where pubtime = 20 for update;
  8. +-----+---------+
  9. | id  | pubtime |
  10. +-----+---------+
  11. | 100 |      20 |
  12. +-----+---------+
  13. 1 row in set (0.04 sec)
  15. # 查看当前锁信息
  16. # 可以明显的看到当前加的X,GAP锁,而GAP间隙锁锁的间隙可以在lock_data列中看到,锁的是100 - 6主键中对应 pubtime 的数据
  17. # 而id = 100 的 pubtime = 20, id = 6 的 pubtime = 100, 
  18. # 也就是说我们可以插入的 pubtime 数据要么小于20, 要么大于100, 我们去session2中试一下
  19. mysql> SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;
  20. +---------------------+-------------+-----------+-----------+--------------------+---------------+------------+-----------+----------+-----------+
  21. | lock_id             | lock_trx_id | lock_mode | lock_type | lock_table         | lock_index    | lock_space | lock_page | lock_rec | lock_data |
  22. +---------------------+-------------+-----------+-----------+--------------------+---------------+------------+-----------+----------+-----------+
  23. | 194477958:8190:4:10 | 194477958   | X,GAP     | RECORD    | `test`.`t1_simple` | pubtime_index |       8190 |         4 |       10 | 100, 6    |
  24. | 194477529:8190:4:10 | 194477529   | X,GAP     | RECORD    | `test`.`t1_simple` | pubtime_index |       8190 |         4 |       10 | 100, 6    |
  25. +---------------------+-------------+-----------+-----------+--------------------+---------------+------------+-----------+----------+-----------+
  26. 2 rows in set (0.05 sec)
  28. mysql> rollback;
  29. Query OK, 0 rows affected (0.00 sec)
  1. # session2
  3. mysql> begin;
  4. Query OK, 0 rows affected (0.00 sec)
  6. # 看一下当前表中的数据
  7. mysql> select * from t1_simple;
  8. +-----+---------+
  9. | id  | pubtime |
  10. +-----+---------+
  11. |  10 |       1 |
  12. |  13 |       1 |
  13. |   4 |       3 |
  14. |  11 |       4 |
  15. |   8 |       5 |
  16. |  12 |       9 |
  17. |   1 |      10 |
  18. | 100 |      20 |
  19. |   6 |     100 |
  20. +-----+---------+
  21. 9 rows in set (0.03 sec)
  23. # 阻塞。此时我们回到session1执行一下锁信息,看一下锁的情况
  24. mysql> insert into t1_simple values (101, 21);
  26. # 小于20,成功
  27. mysql> insert into t1_simple values (9, 2);
  28. Query OK, 1 row affected (0.00 sec)
  30. # 大于100,成功
  31. mysql> insert into t1_simple values (101, 101);
  32. Query OK, 1 row affected (0.01 sec)
  34. # 插入 20 - 100直接的数据25, 则阻塞
  35. mysql> insert into t1_simple values (20, 25);
  37. mysql> rollback;
  38. Query OK, 0 rows affected (0.00 sec)

插入意向锁(Insert Intention Locks)

  • 插入意向锁是一种Gap锁，不是意向锁，在insert操作时产生。
  • 在多事务同时写入不同数据至同一索引间隙的时候，并不需要等待其他事务完成，不会发生锁等待。
  • 假设有一个记录索引包含键值4和7，不同的事务分别插入5和6，每个事务都会产生一个加在4-7之间的插入意向锁，获取在插入行上的排它锁，但是不会被互相锁住，因为数据行并不冲突。
  • 插入意向锁不会阻止任何锁，对于插入的记录会持有一个记录锁。