InnoDB的锁机制浅析(All in One)

目录

• InnoDB的锁机制浅析
  • 1. 前言
  • 2. 锁基本概念
    • 2.1 共享锁和排它锁
    • 2.2 意向锁-Intention Locks
    • 2.3 锁的兼容性
  • 3. InnoDB中的锁
    • 3.1 准备工做
    • 3.2 记录锁 Record Locks
    • 3.3 间隙锁 Gap Locks
    • 3.4 Next-key Locks
    • 3.5 插入意向锁 Insert Intention Locks
    • 3.6 自增锁
  • 4 幻读
    • 4.1 幻读概念
    • 4.2 RC级别下的幻读
    • 4.3 RR级别下可否避免幻读？
    • 4.5 更新丢失(Lost Update)
  • 5. InnoDB对不一样语句执行时的加锁情况
    • 5.1 SELECT ... FROM...不加锁
    • 5.2 UPDATE系列
    • 5.3 INSERT
  • 6. 可能的死锁场景
    • 6.1 Duplicate key error引起的死锁
    • 6.2 数据插入的过程
    • 6.3 GAP与Insert Intention冲突引起死锁
  • 7 总结

InnoDB的锁机制浅析

本文是大而全版（五合一）：InnoDB的锁机制浅析(All in One)

若是想分开看能够点击下面连接：

文章总共分为五个部分：

• InnoDB的锁机制浅析(一)—基本概念/兼容矩阵
• InnoDB的锁机制浅析(二)—探索InnoDB中的锁(Record锁/Gap锁/Next-key锁/插入意向锁)
• InnoDB的锁机制浅析(三)—幻读
• InnoDB的锁机制浅析(四)—不一样SQL的加锁情况
• InnoDB的锁机制浅析(五)—死锁场景(Insert死锁)

1. 前言

数据事务设计遵循ACID的原则。

MySQL数据库提供了四种默认的隔离级别，读未提交(read-uncommitted)、读已提交(或不可重复读)(read-committed)、可重复读(repeatable-read)、串行化(serializable)。

MySQL的默认隔离级别是RR。

2. 锁基本概念

2.1 共享锁和排它锁

InnoDB实现了两种标准行级锁，一种是共享锁(shared locks，S锁)，另外一种是独占锁，或者叫排它锁(exclusive locks，X锁)。

S锁容许当前持有该锁的事务读取行。
X锁容许当前持有该锁的事务更新或删除行。

S锁

若是事务T1持有了行r上的S锁，则其余事务能够同时持有行r的S锁，可是不能对行r加X锁。

X锁

若是事务T1持有了行r上的X锁，则其余任何事务不能持有行r的X锁，必须等待T1在行r上的X锁释放。

若是事务T1在行r上保持S锁，则另外一个事务T2对行r的锁的请求按以下方式处理：

• T2能够同时持有S锁
• T2若是想在行r上获取X锁，必须等待其余事务对该行添加的S锁或X锁的释放。

2.2 意向锁-Intention Locks

InnoDB支持多种粒度的锁，容许行级锁和表级锁的共存。例如LOCK TABLES ... WRITE等语句能够在指定的表上加上独占锁。
InnoBD使用意向锁来实现多个粒度级别的锁定。意向锁是表级锁，表示table中的row所须要的锁(S锁或X锁)的类型。

意向锁分为意向共享锁(IS锁)和意向排它锁(IX锁)。
IS锁表示当前事务意图在表中的行上设置共享锁，下面语句执行时会首先获取IS锁，由于这个操做在获取S锁：

SELECT ... LOCK IN SHARE MODE

IX锁表示当前事务意图在表中的行上设置排它锁。下面语句执行时会首先获取IX锁，由于这个操做在获取X锁：

SELECT ... FOR UPDATE

事务要获取某个表上的S锁和X锁以前，必须先分别获取对应的IS锁和IX锁。

2.3 锁的兼容性

锁的兼容矩阵以下：

---	排它锁(X)	意向排它锁(IX)	共享锁(S)	意向共享锁(IS)
排它锁(X)	N	N	N	N
意向排它锁(IX)	N	OK	N	OK
共享锁(S)	N	N	OK	OK
意向共享锁(IS)	N	OK	OK	OK

按照上面的兼容性，若是不一样事务之间的锁兼容，则当前加锁事务能够持有锁，若是有冲突则会等待其余事务的锁释放。

若是一个事务请求锁时，请求的锁与已经持有的锁冲突而没法获取时，互相等待就可能会产生死锁。

意向锁不会阻止除了全表锁定请求以外的任何锁请求。
意向锁的主要目的是显示事务正在锁定某行或者正意图锁定某行。

3. InnoDB中的锁

常见的锁有Record锁、gap锁、next-key锁、插入意向锁、自增锁等。
下面会对每一种锁给出一个查看锁的示例。

3.1 准备工做

3.1.1 测试用表结构

示例的基础是一个只有两列的数据库表。

mysql> CREATE TABLE test (
id int(11) NOT NULL,
code int(11) NOT NULL, 
PRIMARY KEY(id), 
KEY (code)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; 

mysql> INSERT INTO test(id,code) values(1,1),(10,10);

数据表test只有两列，id是主键索引，code是普通的索引(注意，必定不要是惟一索引)，并初始化了两条记录，分别是(1,1),(10,10)。
这样，咱们验证惟一键索引就可使用id列，验证普通索引(非惟一键二级索引)时就使用code列。

3.1.2 查看锁状态的方式

要看到锁的状况，必须手动开启多个事务，其中一些锁的状态的查看则必须使锁处于waiting状态，这样才能在mysql的引擎状态日志中看到。

命令：

mysql> show engine innodb status;

这条命令能显示最近几个事务的状态、查询和写入状况等信息。当出现死锁时，命令能给出最近的死锁明细。

3.2 记录锁 Record Locks

Record锁

Record Lock是对索引记录的锁定。记录锁有两种模式，S模式和X模式。
例如SELECT id FROM test WHERE id = 10 FOR UPDATE;表示防止任何其余事务插入、更新或者删除id =10的行。

记录锁始终只锁定索引。即便表没有创建索引，InnoDB也会建立一个隐藏的聚簇索引(隐藏的递增主键索引)，并使用此索引进行记录锁定。

查看记录锁

开启第一个事务，不提交，测试完以后回滚。

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update test set id=2 where id=1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

事务加锁状况

mysql> show engine innodb status\G;
... 
------------
TRANSACTIONS
------------
---TRANSACTION 366811, ACTIVE 690 sec
2 lock struct(s), heap size 1136, 1 row lock(s), undo log entries 2
MySQL thread id 785, OS thread handle 123145432457216, query id 729076 localhost 127.0.0.1 root
...

能够看到有一行被加了锁。由以前对锁的描述能够推测出，update语句给id=1这一行上加了一个X锁。

注意：X锁广义上是一种抽象意义的排它锁，即锁通常分为X模式和S模式，狭义上指row或者index上的锁，而Record锁是索引上的锁。
为了避免修改数据，能够用select ... for update语句，加锁行为和update、delete是同样的，insert加锁机制较为复杂，后面的章节会提到。

第一个事务保持原状，不要提交或者回滚，如今开启第二个事务。

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update test set id=3 where id=1;

执行update时，sql语句的执行被阻塞了。查看下事务状态:

mysql> show engine innodb status\G;
...
------- TRX HAS BEEN WAITING 4 SEC FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 62 page no 3 n bits 72 index PRIMARY of table `test`.`test` trx id 366820 lock_mode X locks rec but not gap waiting
Record lock, heap no 2 PHYSICAL RECORD: n_fields 3; compact format; info bits 32
 0: len 8; hex 0000000000000001; asc         ;;
 1: len 6; hex 0000000598e3; asc       ;;
 2: len 7; hex 7e000001a80896; asc ~      ;;

------------------
...

喜闻乐见，咱们看到了这个锁的状态。状态标题是'事务正在等待获取锁'，描述中的lock_mode X locks rec but not gap就是本章节中的record记录锁，直译一下'X锁模式锁住了记录'。后面还有一句but not gap意思是只对record自己加锁，并不对间隙加锁，间隙锁的叙述见下一个章节。

3.3 间隙锁 Gap Locks

间隙锁

间隙锁做用在索引记录之间的间隔，又或者做用在第一个索引以前，最后一个索引以后的间隙。不包括索引自己。
例如，SELECT c1 FROM t WHERE c1 BETWEEN 10 and 20 FOR UPDATE;这条语句阻止其余事务插入10和20之间的数字，不管这个数字是否存在。

间隙能够跨越0个，单个或多个索引值。

间隙锁是性能和并发权衡的产物，只存在于部分事务隔离级别。

select * from table where id=1;
惟一索引能够锁定一行，因此不须要间隙锁锁定。
若是列没有索引或者具备非惟一索引，该语句会锁定当前索引前的间隙。

在同一个间隙上，不一样的事务能够持有上述兼容/冲突表中冲突的两个锁。例如，事务T1如今持有一个间隙S锁，T2能够同时在同一个间隙上持有间隙X锁。
容许冲突的锁在间隙上锁定的缘由是，若是从索引中清除一条记录，则由不一样事务在这条索引记录上的加间隙锁的动做必须被合并。

InnoDB中的间隙锁的惟一目的是防止其余事务插入间隙。
间隙锁是能够共存的，一个事务占用的间隙锁不会阻止另外一个事务获取同一个间隙上的间隙锁。

若是事务隔离级别改成RC，则间隙锁会被禁用。

查看间隙锁

按照官方文档，where子句查询条件是惟一键且指定了值时，只有record锁，没有gap锁。
若是where语句指定了范围，gap锁是存在的。
这里只测试验证一下当指定非惟一键索引的时候，gap锁的位置，按照文档的说法，会锁定当前索引及索引以前的间隙。(指定了非惟一键索引,例如code=10，间隙锁仍然存在)

开启第一个事务，锁定一条非惟一的普通索引记录

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from test where code = 10 for update;
+----+------+
| id | code |
+----+------+
| 10 |   10 |
+----+------+
1 row in set (0.00 sec)

因为预存了两条数据，row(1,1)和row(10,10)，此时这个间隙应该是1<gap<10。咱们先插入row(2,2)来验证下gap锁的存在，再插入row(0,0)来验证gap的边界。

按照间隙锁的官方文档定义，select * from test where code = 10 for update;会锁定code=10这个索引，而且会锁定code<10的间隙。

开启第二个事务，在code=10以前的间隙中插入一条数据，看下这条数据是否可以插入。

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into test values(2,2);

插入的时候，执行被阻塞，查看引擎状态：

mysql> show engine innodb status\G;
...
---TRANSACTION 366864, ACTIVE 5 sec inserting
mysql tables in use 1, locked 1
LOCK WAIT 2 lock struct(s), heap size 1136, 1 row lock(s), undo log entries 1
MySQL thread id 793, OS thread handle 123145434963968, query id 730065 localhost 127.0.0.1 root update
insert into test values(2,2)
------- TRX HAS BEEN WAITING 5 SEC FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 63 page no 4 n bits 72 index code of table `test`.`test` trx id 366864 lock_mode X locks gap before rec insert intention waiting
Record lock, heap no 3 PHYSICAL RECORD: n_fields 2; compact format; info bits 0
 0: len 8; hex 800000000000000a; asc         ;;
 1: len 8; hex 000000000000000a; asc         ;;

------------------
...

插入语句被阻塞了，lock_mode X locks gap before rec，因为第一个事务锁住了1到10之间的gap，须要等待获取锁以后才能插入。

若是再开启一个事务，插入(0,0)

mysql> start transaction;
mysql> insert into test values(0,0);
Query OK, 1 row affected (0.00 sec)

能够看到：指定的非惟一建索引的gap锁的边界是当前索引到上一个索引之间的gap。

最后给出锁定区间的示例,首先插入一条记录(5,5)

mysql> insert into test values(5,5);
Query OK, 1 row affected (0.00 sec)

开启第一个事务:

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from test where code between 1 and 10 for update;
+----+------+
| id | code |
+----+------+
|  1 |    1 |
|  5 |    5 |
| 10 |   10 |
+----+------+
3 rows in set (0.00 sec)

第二个事务，试图去更新code=5的行：

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> update test set code=4 where code=5;

执行到这里，若是第一个事务不提交或者回滚的话，第二个事务一直等待直至mysql中设定的超时时间。

3.4 Next-key Locks

Next-key锁

Next-key锁其实是Record锁和gap锁的组合。Next-key锁是在下一个索引记录自己和索引以前的gap加上S锁或是X锁(若是是读就加上S锁，若是是写就加X锁)。
默认状况下，InnoDB的事务隔离级别为RR，系统参数innodb_locks_unsafe_for_binlog的值为false。InnoDB使用next-key锁对索引进行扫描和搜索，这样就读取不到幻象行，避免了幻读的发生。

幻读是指在同一事务下，连续执行两次一样的SQL语句，第二次的SQL语句可能会返回以前不存在的行。

当查询的索引是惟一索引时，Next-key lock会进行优化，降级为Record Lock，此时Next-key lock仅仅做用在索引自己，而不会做用于gap和下一个索引上。

查看Next-key锁

Next-key锁的做用范围

如上述例子，数据表test初始化了row(1,1),row(10,10)，而后插入了row(5,5)。数据表以下：

mysql> select * from test;
+----+------+
| id | code |
+----+------+
|  1 |    1 |
|  5 |    5 |
| 10 |   10 |
+----+------+
3 rows in set (0.00 sec)

因为id是主键、惟一索引，mysql会作优化，所以使用code这个非惟一键的二级索引来举例说明。

对于code，可能的next-key锁的范围是：

(-∞,1]
(1,5]
(5,10]
(10,+∞)

开启第一个事务，在code=5的索引上请求更新:

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from test where code=5 for update;
+----+------+
| id | code |
+----+------+
|  5 |    5 |
+----+------+
1 row in set (8.81 sec)

以前在gap锁的章节中介绍了，code=5 for update会在code=5的索引上加一个record锁，还会在1<gap<5的间隙上加gap锁。如今再也不验证，直接插入一条(8,8)：

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into test values(8,8);

insert处于等待执行的状态，这就是next-key锁生效而致使的结果。第一个事务，锁定了区间(1,5]，因为RR的隔离级别下next-key锁处于开启生效状态，又锁定了(5,10]区间。因此插入SQL语句的执行被阻塞。

解释：在这种状况下，被锁定的区域是code=5前一个索引到它的间隙，以及next-key的区域。code=5 for update对索引的锁定用区间表示，gap锁锁定了(1,5)，record锁锁定了{5}索引记录，next-key锁锁住了(5,10]，也就是说整个(1,10]的区间被锁定了。因为是for update，因此这里的锁都是X锁，所以阻止了其余事务中带有冲突锁定的操做执行。

若是咱们在第一个事务中，执行了code>8 for update，在扫描过程当中，找到了code=10，此时就会锁住10以前的间隙(5到10之间的gap)，10自己(record)，和10以后的间隙(next-key)。此时另外一个事务插入(6,6),(9,9)和(11,11)都是不被容许的，只有在前一个索引5及5以前的索引和间隙才能执行插入(更新和删除也会被阻塞)。

3.5 插入意向锁 Insert Intention Locks

插入意向锁在行插入以前由INSERT设置一种间隙锁，是意向排它锁的一种。
在多事务同时写入不一样数据至同一索引间隙的时，不会发生锁等待，事务之间互相不影响其余事务的完成，这和间隙锁的定义是一致的。

假设一个记录索引包含4和7，其余不一样的事务分别插入5和6，此时只要行不冲突，插入意向锁不会互相等待，能够直接获取。参照锁兼容/冲突矩阵。
插入意向锁的例子再也不列举，能够查看gap锁的第一个例子。

3.6 自增锁

自增锁(AUTO-INC Locks)是事务插入时自增列上特殊的表级别的锁。最简单的一种状况：若是一个事务正在向表中插入值，则任何其余事务必须等待，以便第一个事务插入的行接收连续的主键值。

咱们通常把主键设置为AUTO_INCREMENT的列，默认状况下这个字段的值为0，InnoDB会在AUTO_INCREMENT修饰下的数据列所关联的索引末尾设置独占锁。在访问自增计数器时，InnoDB使用自增锁，可是锁定仅仅持续到当前SQL语句的末尾，而不是整个事务的结束，毕竟自增锁是表级别的锁，若是长期锁定会大大下降数据库的性能。因为是表锁，在使用期间，其余会话没法插入表中。

4 幻读

这一章节，咱们经过幻读，逐步展开对InnoDB锁的探究。

4.1 幻读概念

解释了不一样概念的锁的做用域，咱们来看一下幻读究竟是什么。幻读在RR条件下是不会出现的。由于RR是Repeatable Read，它是一种事务的隔离级别，直译过来也就是“在同一个事务中，一样的查询语句的读取是可重复”，也就是说他不会读到”幻影行”(其余事务已经提交的变动)，它读到的只能是重复的(不管在第一次查询以后其余事务作了什么操做，第二次查询结果与第一次相同)。

上面的例子都是使用for update，这种读取操做叫作当前读，对于普通的select语句均为快照读。

当前读，又叫加锁读，或者 阻塞读。这种读取操做再也不是读取快照，而是读取最新版本而且加锁。
快照读不会添加任何锁。

官方文档对于幻读的定义是这样的：

原文：The so-called phantom problem occurs within a transaction when the same query produces different sets of rows at different times. For example, if a SELECT is executed twice, but returns a row the second time that was not returned the first time, the row is a “phantom” row.
手动无脑翻译：所谓的幻影行问题是指，在同一个事务中，一样的查询语句执行屡次，获得了不一样的结果，这就是幻读。例如，若是同一个SELECT语句执行了两次，第二次执行的时候比第一次执行时多出一行，则该行就是所谓的幻影行。

The so-called phantom problem occurs within a transaction when the same query produces different sets of rows at different times.，这句话看起来应该是不可重复读的定义，一样的查询获得了不一样的结果(两次结果不是重复的)，可是后面的举例给出了幻读真正的定义，第二次比第一次多出了一行。也就是说，幻读的出现有这样一个前提，第二次查询前其余事务提交了一个INSERT插入语句。而不可重复读出现的前提是第二次查询前其余事务提交了UPDATE或者DELETE操做。

mysql的快照读，使得在RR的隔离级别上在next-Key的做用区间内，制造了一个快照副本，这个副本是隔离的，不管副本对应的区间里的数据被其余事务如何修改，在当前事务中，取到的数据永远是副本中的数据。
RR级别下之因此能够读到以前版本的数据，是因为数据库的MVCC(Multi-Version Concurrency Control，多版本并发控制)。参见InnoDB Multi-Versioning

有些文章中提到“RR也不能彻底避免幻读”，实际上官方文档实际要表达的意义是“在同一个事务内，屡次连续查询的结果是同样的，不会因其余事务的修改而致使不一样的查询结果”，这里先给出实验结论：

1.当前事务若是未发生更新操做(增删改)，快照版本会保持不变，屡次查询读取的副本是同一个。
2.当前事务若是发生更新(增删改)，再次查询时，会刷新快照版本。

4.2 RC级别下的幻读

RC状况下会出现幻读。
首先设置隔离级别为RC,SET SESSION tx_isolation='READ-COMMITTED';

事务一	事务二
mysql> SET SESSION tx_isolation='READ-COMMITTED'; mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)
	mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values(9,9); Query OK, 1 row affected (0.00 sec) mysql> commit; Query OK, 0 rows affected (0.00 sec)
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 9 | 9 | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)

RC(Read Commit)隔离级别能够避免脏读，事务内没法获取其余事务未提交的变动，可是因为可以读到已经提交的事务，所以会出现幻读和不重复读。
也就是说，RC的快照读是读取最新版本数据，而RR的快照读是读取被next-key锁做用区域的副本

4.3 RR级别下可否避免幻读？

咱们先来模拟一下RR隔离级别下没有出现幻读的状况：

开启第一个事务并执行一次快照查询。

事务一	事务二
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)
	mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values(9,9); Query OK, 1 row affected (0.00 sec) mysql> commit; Query OK, 0 rows affected (0.00 sec)
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)

这两个事务的执行，有两个问题：

1.为何以前的例子中，在第二个事务的INSERT被阻塞了，而此次却执行成功了。
这是由于原来的语句中带有for update，这种读取是当前读，会加锁。而本次第一个事务中的SELECT仅仅是快照读，没有加任何锁。因此不会阻塞其余的插入。

2.数据库中的数据已经改变，为何会读不到？
这个就是以前提到的next-key lock锁定的副本。RC及如下级别才会读到已经提交的事务。更多的业务逻辑是但愿在某段时间内或者某个特定的逻辑区间中，先后查询到的数据是一致的，当前事务是和其余事务隔离的。这也是数据库在设计实现时遵循的ACID原则。

再给出RR条件下出现幻读的情形，这种情形不须要两个事务，一个事务就已经能够说明，

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from test where id>8;
+----+------+
| id | code |
+----+------+
| 10 |   10 |
+----+------+
1 row in set (0.00 sec)

mysql> update test set code=9 where id=10;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from test where id>8;
+----+------+
| id | code |
+----+------+
| 10 |    9 |
+----+------+
1 row in set (0.00 sec)

至于RR隔离级别下到底会不会出现幻读，就须要看幻读的定义中的查询究竟是连续的查询仍是不连续的查询。若是认为RR级别下可能会出现幻读，那该级别下也会出现不重复读。

---

RR隔离级别下，虽然不会出现幻读，可是会所以产生其余的问题。
前提：当前数据表中只存在(1,1),(5,5),(10,10)三组数据。

若是数据库隔离级别不是默认，能够执行SET SESSION tx_isolation='REPEATABLE-READ';(该语句不是全局设置)更新为RR。

而后执行下列操做:

事务一	事务二	备注
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)		开启事务一，并查询code>8的记录，只有一条(10,10)
	mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values(11,11); Query OK, 1 row affected (0.00 sec) mysql> commit; Query OK, 0 rows affected (0.00 sec)	开启第二个事务，插入(11,11)并提交
mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)		事务一再查询一次，因为RR级别并无读到更新
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values(11,11); ERROR 1062 (23000): Duplicate entry '11' for key 'PRIMARY'		事务一明明没有查到，却插入不了

4.5 更新丢失(Lost Update)

4.5.1 更新丢失

除了上述这类问题外，RR还会有丢失更新的问题。
以下表给出的操做：

事务一	事务二	备注
mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)		开启事务一，并查询code>8的记录，只有一条(10,10)
	mysql> start transaction; Query OK, 0 rows affected (0.00 sec) mysql> update test set id=12,code=12 where id=10; Query OK, 1 row affected (0.00 sec) Rows matched: 1 Changed: 1 Warnings: 0 mysql> commit; Query OK, 0 rows affected (0.00 sec)	开启第二个事务，将(10,10)改成(12,12)并提交，注意这里matched是1，changed也是1
mysql> select * from test where code > 8; +----+------+ | id | code | +----+------+ | 10 | 10 | +----+------+ 1 row in set (0.01 sec)		事务一再次查询code>8的记录，仍然只有一条(10,10)
mysql> update test set id=9,code=9 where id=10; Query OK, 0 row affected (0.00 sec) mysql> commit; Query OK, 0 rows affected (0.00 sec) Rows matched: 0 Changed: 0 Warnings: 0		这里查询到0条，更新了0条

这个例子里，事务一的更新是无效的，尽管在这个事务里程序认为还存在(10,10)记录。
事务一中更新以前的SELECT操做是快照读，因此读到了快照里的(10,10)，而UPDATE中的WHERE子句是当前读，取得是最新版本的数据，因此matched: 0 Changed: 0。

若是上述例子中的操做是对同一条记录作修改，就会引发更新丢失。例如，事务一和二同时开启，事务一先执行update test set code=100 where id=10;，事务二再执行update test set code=200 where id=10;，事务一的更新就会被覆盖。

这就是经典的丢失更新问题，英文叫Lost Update，又叫提交覆盖，由于是最后执行更新的事务提交致使的覆盖。还有一种更新丢失叫作回滚覆盖，即一个事务的回滚把另外一个事务提交的数据给回滚覆盖了，可是目前市面上全部的数据库都不支持这种stupid的操做，所以再也不详述。

4.5.2 乐观锁与悲观锁

这种状况下，引入咱们常见的两种方式来解决该问题

• 乐观锁：在UPDATE的WHERE子句中加入版本号信息来肯定修改是否生效
• 悲观锁：在UPDATE执行前，SELECT后面加上FOR UPDATE来给记录加锁，保证记录在UPDATE前不被修改。SELECT ... FOR UPDATE是加上了X锁，也能够经过SELECT ... LOCK IN SHARE MODE加上S锁，来防止其余事务对该行的修改。

不管是乐观锁仍是悲观锁，使用的思想都是一致的，那就是当前读。乐观锁利用当前读判断是不是最新版本，悲观锁利用当前读锁定行。
可是使用乐观锁时仍然须要很是谨慎，由于RR是可重复读的，必定不能在UPDATE以前先把版本号读取出来。

5. InnoDB对不一样语句执行时的加锁情况

若是一个SQL语句要对二级索引(非主键索引)设置X模式的Record锁，InnoDB还会检索出相应的聚簇索引(主键索引)并对它们设置锁定。

5.1 SELECT ... FROM...不加锁

SELECT ... FROM是快照读取，除了SERIALIZABLE的事务隔离级别，该SQL语句执行时不会加任何锁。

SERIALIZABLE级别下，SELECT语句的执行会在遇到的索引记录上设置S模式的next-key锁。可是对于惟一索引，只锁定索引记录，而不会锁定gap。

5.2 UPDATE系列

S锁读取(SELECT ... LOCK IN SHARE MODE)，X锁读取(SELECT ... FOR UPDATE)、更新UPDATE和删除DELETE这四类语句，采用的锁取决于搜索条件中使用的索引类型。

• 若是使用惟一索引，InnoDB仅锁定索引记录自己，不锁定间隙。
• 若是使用非惟一索引，或者未命中索引，InnoDB使用间隙锁或者next-key锁来锁定索引范围，这样就能够阻止其余事务插入锁定范围。

5.2.1 UPDATE语句

UPDATE ... WHERE ...在搜索遇到的每条记录上设置一个独占的next-key锁，若是是惟一索引只锁定记录。
当UPDATE修改聚簇索引时，将对受影响的二级索引采用隐式锁，隐式锁是在索引中对二级索引的记录逻辑加锁，实际上不产生锁对象，不占用内存空间。

例如update test set code=100 where id=10;执行的时候code=10的索引(code是二级索引，见文中给出的建表语句)会被加隐式锁，只有隐式锁产生冲突时才会变成显式锁(如S锁、X锁)。即此时另外一个事务也去更新id=10这条记录，隐式锁就会升级为显示锁。
这样作的好处是下降了锁的开销。

UPDATE可能会致使新的普通索引的插入。当新的索引插入以前，会首先执行一次重复索引检查。在重复检查和插入时，更新操做会对受影响的二级索引记录采用共享锁定(S锁)。

5.2.2 DELETE语句

DELETE FROM ... WHERE ...在搜索遇到的每条记录上设置一个独占的next-key锁,若是是惟一索引只锁定记录。

5.3 INSERT

INSERT区别于UPDATE系列单独列出，是由于它的处理方式较为特别。

插入行以前，会设置一种插入意向锁，插入意向锁表示插入的意图。若是其它事务在要插入的位置上设置了X锁，则没法获取插入意向锁，插入操做也所以阻塞。

INSERT在插入的行上设置X锁。该锁是一个Record锁，并非next-key锁，即只锁定记录自己，不锁定间隙，所以不会阻止其余会话在这行记录前的间隙中插入新的记录。
具体的加锁过程，见6.2。

6. 可能的死锁场景

6.1 Duplicate key error引起的死锁

并发条件下，惟一键索引冲突可能会致使死锁，这种死锁通常分为两种，一种是rollback引起，另外一种是commit引起。

6.1.1 rollback引起的Duplicate key死锁

我命名为insert-insert-insert-rollback死锁

事务一	事务二	事务三
mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values (2,2); Query OK, 1 row affected (0.01 sec)
	mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values (2,2); 执行以后被阻塞，等待事务一
		mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values (2,2); 执行以后被阻塞，等待事务一
mysql>rollback; Query OK, 0 rows affected (0.00 sec)
	ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
		Query OK, 1 row affected (16.13 sec)

当事务一执行回滚时，事务二和事务三发生了死锁。InnoDB的死锁检测一旦检测到死锁发生，会自动失败其中一个事务，所以看到的结果是一个失败另外一个成功。

为何会死锁？

死锁产生的缘由是事务一插入记录时，对(2,2)记录加X锁，此时事务二和事务三插入数据时检测到了重复键错误，此时事务二和事务三要在这条索引记录上设置S锁，因为X锁的存在，S锁的获取被阻塞。
事务一回滚，因为S锁和S锁是能够兼容的，所以事务二和事务三都得到了这条记录的S锁，此时其中一个事务但愿插入，则该事务指望在这条记录上加上X锁，然而另外一个事务持有S锁，S锁和X锁互相是不兼容的，两个事务就开始互相等待对方的锁释放，形成了死锁。

事务二和事务三为何会加S锁，而不是直接等待X锁

事务一的insert语句加的是隐式锁(隐式的Record锁、X锁)，可是其余事务插入同一行记录时，出现了惟一键冲突，事务一的隐式锁升级为显示锁。
事务二和事务三在插入以前判断到了惟一键冲突，是由于插入前的重复索引检查，此次检查必须进行一次当前读，因而非惟一索引就会被加上S模式的next-key锁，惟一索引就被加上了S模式的Record锁。
由于插入和更新以前都要进行重复索引检查而执行当前读操做，因此RR隔离级别下，同一个事务内不连续的查询，可能也会出现幻读的效果(但我的并不认为RR级别下也会出现幻读，幻读的定义应该是连续的读取)。而连续的查询因为都是读取快照，中间没有当前读的操做，因此不会出现幻读。

6.1.2 commit引起的Duplicate key死锁

delete-insert-insert-commit死锁

事务一	事务二	事务三
mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> delete from test where id=2; Query OK, 1 row affected (0.01 sec)
	mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values (2,2); 执行以后被阻塞，等待事务一
		mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into test values (2,2); 执行以后被阻塞，等待事务一
mysql>commit; Query OK, 0 rows affected (0.00 sec)
	ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
		Query OK, 1 row affected (2.37 sec)

这种状况下产生的死锁和insert-insert-insert-rollback死锁产生的原理一致。

6.2 数据插入的过程

通过以上分析，一条数据在插入时通过如下几个过程：
假设数据表test.test中存在(1,1)、(5,5)和(10,10)三条记录。

• 事务开启，尝试获取插入意向锁。例如，事务一执行了select * from test where id>8 for update，事务二要插入(9,9)，此时先要获取插入意向锁，因为事务一已经在对应的记录和间隙上加了X锁，所以事务二被阻塞，而且阻塞的缘由是获取插入意向锁时被事务一的X锁阻塞。
• 获取意向锁以后，插入以前进行重复索引检查。重复索引检查为当前读，须要添加S锁。
• 若是是已经存在惟一索引，且索引未加锁。直接抛出Duplicate key的错误。若是存在惟一索引，且索引加锁，等待锁释放。
• 重复检查经过以后，加入X锁，插入记录

6.3 GAP与Insert Intention冲突引起死锁

update-insert死锁

仍然是表test，当前表中的记录以下:

mysql> select * from test;
+----+------+
| id | code |
+----+------+
|  1 |    1 |
|  5 |    5 |
| 10 |   10 |
+----+------+
3 rows in set (0.01 sec)

事务一	事务二
begin;	begin;
select * from test where code=5 for update;	select * from test where code=10 for update;
insert into test values(7,7);
	insert into test values(7,7);
Query OK, 1 row affected (5.03 sec)
	ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

使用show engine innodb status查看死锁状态。前后出现lock_mode X locks gap before rec insert intention waiting和lock_mode X locks gap before rec字眼，是gap锁和插入意向锁的冲突致使的死锁。

回顾select...for update的加锁范围

首先回顾一下两个事务中的select ... for update作了哪些加锁操做。

code=5时，首先会获取code=5的索引记录锁(Record锁)，根据以前gap锁的介绍，会在前一个索引和当前索引之间的间隙加锁，因而区间(1,5)之间被加上了X模式的gap锁。除此以外RR模式下，还会加next-key锁，因而区间(5,10]被加了next-key锁；

• 所以，code=5的加锁范围是，区间(1,5)的gap锁，{5}索引Record锁，(5,10]的next-key锁。即区间(1,10)上都被加上了X模式的锁。
• 同理，code=10的加锁范围是，区间(5,10)的gap锁,{10}索引Record锁，（10,+∞)的next-key锁。

由gap锁的特性，兼容矩阵中冲突的锁也能够被不一样的事务同时加在一个间隙上。上述两个select ... for update语句出现了间隙锁的交集，code=5的next-key锁和code=10的gap锁有重叠的区域——(5,10)。

死锁的成因

当事务一执行插入语句时，会先加X模式的插入意向锁，即兼容矩阵中的IX锁。
可是因为插入意向锁要锁定的位置存在X模式的gap锁。兼容矩阵中IX和X锁是不兼容的，所以事务一的IX锁会等待事务二的gap锁释放。

事务二也执行插入语句，与事务一一样，事务二的插入意向锁IX锁会等待事务一的gap锁释放。

两个事务互相等待对方先释放锁，所以出现死锁。

7 总结

除了以上给出的几种死锁模式，还有不少其余死锁的场景。
不管是哪一种场景，万变不离其宗，都是因为某个区间上或者某一个记录上能够同时持有锁，例如不一样事务在同一个间隙gap上的锁不冲突；不一样事务中，S锁能够阻塞X锁的获取，可是不会阻塞另外一个事务获取该S锁。这样才会出现两个事务同时持有锁，并互相等待，最终致使死锁。

其中须要注意的点是，增、删、改的操做都会进行一次当前读操做，以此获取最新版本的数据，并检测是否有重复的索引。
这个过程除了会致使RR隔离级别下出现死锁以外还会致使其余两个问题：

• 第一个是可重复读可能会由于此次的当前读操做而中断，(一样，幻读可能也会所以产生)；
• 第二个是其余事务的更新可能会丢失(解决方式:悲观锁、乐观锁)。