• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

MySQL 事务与锁详解

MySQL winrains 来源:周鑫磊 8个月前 (03-31) 78次浏览

1 什么是数据库的事务?

1.1 事务的典型场景

比如下单,会操作订单表,资金表,物流表等等,这个时候我们需要让这些操作都在一个事务里面完成。在金融的系统里面事务配置是很常见的,比如行内转账的这种操作,如果我们把它简单地理解为一个账户的余额增加,另一个账户的余额减少的情况(当然实际上要比这复杂),那么这两个动作一定是同时成功或者同时失败的。

1.2 事务的定义

维基百科的定义:事务是数据库管理系统(DBMS)执行过程中的一个逻辑单位,由一个有限的数据库操作序列构成。

这里面有两个关键点,第一个,它是数据库最小的工作单元,是不可以再分的。第二个,它可能包含了一个或者一系列的 DML 语句,包括 insert delete update

1.3 哪些存储引擎支持事务

InnoDB 支持事务,这个也是它成为默认的存储引擎的一个重要原因:
storage-engines另一个是 NDB。

1.4 事务的四大特性

  • 原子性(Atomicity),也就是我们刚才说的不可再分,也就意味着我们对数据库的一系列的操作,要么都是成功,要么都是失败,不可能出现部分成功或者部分失败的情况,以刚才提到的转账的场景为例,一个账户的余额减少,对应一个账户的增加,这两个一定是同时成功或者同时失败的。
    全部成功比较简单,问题是如果前面一个操作已经成功了,后面的操作失败了,怎么让它全部失败呢?这个时候我们必须要回滚。

原子性,在 InnoDB 里面是通过undo log来实现的,它记录了数据修改之前的值(逻辑日志),一旦发生异常,就可以用 undo log 来实现回滚操作。

  • 一致性(consistent),指的是数据库的完整性约束没有被破坏,事务执行的前后都是合法的数据状态。比如主键必须是唯一的,字段长度符合要求。除了数据库自身的完整性约束,还有一个是用户自定义的完整性。
    比如说转账的这个场景,A 账户余额减少 1000,B 账户余额只增加了 500,这个时候因为两个操作都成功了,按照我们对原子性的定义,它是满足原子性的, 但是它没有满足一致性,因为它导致了会计科目的不平衡。还有一种情况,A 账户余额为 0,如果这个时候转账成功了,A 账户的余额会变成 -1000,虽然它满足了原子性的,但是我们知道,借记卡的余额是不能够小于 0 的,所以也违反了一致性。用户自定义的完整性通常要在代码中控制。
  • 隔离性(Isolation),我们有了事务的定义以后,在数据库里面会有很多的事务同时去操作我们的同一张表或者同一行数据,必然会产生一些并发或者干扰的操作,那么我们对隔离性的定义,就是这些很多个的事务,对表或者行的并发操作,应该是透明的,互相不干扰的。通过这种方式,我们最终也是保证业务数据的一致性。
  • 持久性(Durable),事务的持久性是什么意思呢?我们对数据库的任意的操作,增删改,只要事务提交成功,那么结果就是永久性的,不可能因为我们系统宕机或者重启了数据库的服务器,它又恢复到原来的状态了。这个就是事务的持久性。

持久性怎么实现呢?数据库崩溃恢复(crash-safe)是通过什么实现的?

持久性是通过redo log来实现的,我们操作数据的时候,会先写到内存的 buffer pool 里面,同时记录 redo log,如果在刷盘之前出现异常,在重启后就可以读取 redo log 的内容,写入到磁盘,保证数据的持久性。

原子性,隔离性,持久性,最后都是为了实现一致性。

1.5 数据库什么时候会出现事务

当我执行这样一条更新语句的时候,它有事务吗?

update student set sname = '猫老公 111' where id=1;

实际上,它自动开启了一个事务,并且提交了,所以最终写入了磁盘。
这个是开启事务的第一种方式,自动开启和自动提交。

InnoDB 里面有一个autocommit的参数(分成两个级别session 级别和 global 级别)。它的默认值是 ON。

show variables like ‘autocommit’;

autocommit 这个参数是什么意思呢?是否自动提交。如果它的值是 true/on 的话,我们在操作数据的时候,会自动开启一个事务,和自动提交事务。

否则的话,如果我们把 autocommit 设置成 false/off,那么数据库的事务就需要我们手动地去开启和手动地去结束。

手动开启事务也有几种方式,一种是用 begin;一种是用 start transaction。

那么怎么结束一个事务呢?我们结束也有两种方式,第一种就是提交一个事务, commit;还有一种就是 rollback,回滚的时候,事务也会结束。还有一种情况,客户端的连接断开的时候,事务也会结束

1.6 事务并发会带来什么问题?

当很多事务并发地去操作数据库的表或者行的时候,如果没有我们刚才讲的事务的隔离性的时候,会带来哪些问题呢?

transaction1.jpg

大家看一下,我们有两个事务,一个是 Transaction A,一个是 Transaction B,在第一个事务里面,它首先通过一个 where id=1 的条件查询一条数据,返回 name=Ada, age=16 的这条数据。然后第二个事务呢,它同样地是去操作 id=1 的这行数据,它通过一个 update 的语句,把这行 id=1 的数据的 age 改成了 18,但是大家注意,它没有提交。

这个时候,在第一个事务里面,它再次去执行相同的查询操作,发现数据发生了变化,获取到的数据 age 变成了 18。那么,这种在一个事务里面,由于其他的时候修改了数据并且没有提交,而导致了前后两次读取数据不一致的情况,这种事务并发的问题,我们把它定义成脏读

transaction2.jpg

同样是两个事务,第一个事务通过 id=1 查询到了一条数据。然后在第二个事务里面执行了一个 update 操作,这里大家注意一下,执行了 update 以后它通过一个 commit 提交了修改。然后第一个事务读取到了其他事务已提交的数据导致前后两次读取数据不一致的情况,就像这里,age 到底是等于 16 还是 18,那么这种事务并发带来的问题,我们把它叫做不可重复读

transaction3.jpg

在第一个事务里面我们执行了一个范围查询,这个时候满足条件的数据只有一条。在第二个事务里面,它插入了一行数据,并且提交了。重点:插入了一行数据。在第一个事务里面再去查询的时候,它发现多了一行数据。

一个事务前后两次读取数据数据不一致,是由于其他事务插入数据造成的,这种情况我们把它叫做幻读

不可重复读是修改或者删除,幻读是插入

无论是脏读,还是不可重复读,还是幻读,它们都是数据库的读一致性的问题,都是在一个事务里面前后两次读取出现了不一致的情况。

读一致性的问题,必须要由数据库提供一定的事务隔离机制来解决。就像我们去饭店吃饭,基本的设施和卫生保证都是饭店提供的。那么我们使用数据库,隔离性的问题也必须由数据库帮助我们来解决。

1.7 SQL92标准

所以,就有很多的数据库专家联合制定了一个标准,也就是说建议数据库厂商都按照这个标准,提供一定的事务隔离级别,来解决事务并发的问题,这个就是 SQL92 标准。

我们来看一下 SQL92 标准的官网。sql1992
这里面有一张表格(搜索_iso),里面定义了四个隔离级别,右边的 P1 P2 P3 就是代表事务并发的 3 个问题,脏读,不可重复读,幻读。Possible 代表在这个隔离级别下,这个问题有可能发生,换句话说,没有解决这个问题。Not Possible 就是解决了这个问题。

我们详细地分析一下这 4 个隔离级别是怎么定义的。

  • Read Uncommitted(未提交读),一个事务可以读取到其他事务未提交的数据,会出现脏读,所以叫做 RU,它没有解决任何的问题
  • Read Committed(已提交读),也就是一个事务只能读取到其他事务已提交的数据,不能读取到其他事务未提交的数据,它解决了脏读的问题,但是会出现不可重复读的问题。
  • Repeatable Read (可重复读),它解决了不可重复读的问题,也就是在同一个事务里面多次读取同样的数据结果是一样的,但是在这个级别下,没有定义解决幻读的问题。
  • Serializable(串行化),在这个隔离级别里面,所有的事务都是串行执行的,也就是对数据的操作需要排队,已经不存在事务的并发操作了,所以它解决了所有的问题

这个是 SQL92 的标准,但是不同的数据库厂商或者存储引擎的实现有一定的差异,比如 Oracle 里面就只有两种 RC(已提交读)和 Serializable(串行化)。那么 InnoDB 的实现又是怎么样的呢?

1.8 MySQL InnoDB对隔离级别的支持

在 MySQL InnoDB 里面,不需要使用串行化的隔离级别去解决所有问题。那我们来看一下 MySQL InnoDB 里面对数据库事务隔离级别的支持程度是什么样的。

image.png

InnoDB 支持的四个隔离级别和 SQL92 定义的基本一致,隔离级别越高,事务的并发度就越低。唯一的区别就在于,InnoDB 在 RR 的级别就解决了幻读的问题。这个也是 InnoDB 默认使用 RR 作为事务隔离级别的原因,既保证了数据的一致性,又支持较高的并发度。

1.9 两大实现方案

如果要解决读一致性的问题,保证一个事务中前后两次读取数据结果一致,实现事务隔离,应该怎么做?

总体上来说,我们有两大类的方案。

1.9.1 LBCC

第一种,既然要保证前后两次读取数据一致,那么读取数据的时候,锁定我要操作的数据,不允许其他的事务修改就行了。这种方案叫做基于锁的并发控制 Lock Based Concurrency Control(LBCC)。

如果仅仅是基于锁来实现事务隔离,一个事务读取的时候不允许其他时候修改,那就意味着不支持并发的读写操作,而我们的大多数应用都是读多写少的,这样会极大地影响操作数据的效率。

1.9.2 MVCC

innodb-multi-versioning
另一种解决方案,如果要让一个事务前后两次读取的数据保持一致,那么我们可以在修改数据的时候给它建立一个备份或者叫快照,后面再来读取这个快照就行了。这种方案我们叫做多版本的并发控制 Multi Version Concurrency Control(MVCC)。

问题:这个快照什么时候创建?读取数据的时候,怎么保证能读取到这个快照而不是最新的数据?这个怎么实现呢?

MVCC 的核心思想是: 我可以查到在我这个事务开始之前已经存在的数据,即使它在后面被修改或者删除了。在我这个事务之后新增的数据,我是查不到的

InnoDB 为每行记录都实现了两个隐藏字段:

DB_TRX_ID,6 字节:插入或更新行的最后一个事务的事务 ID,事务编号是自动递增的(我们把它理解为创建版本号,在数据新增或者修改为新数据的时候,记录当前事务 ID)。

DB_ROLL_PTR,7 字节:回滚指针(我们把它理解为删除版本号,数据被删除或记录为旧数据的时候,记录当前事务 ID)。

我们把这两个事务 ID 理解为版本号。

[https://processon.com/view/5d29999ee4b07917e2e09294] 第一个事务,初始化数据(检查初始数据)

+-------------------------------------------------------------------------------------------------------+
| Transaction 1 |
+=======================================================================================================+
| begin; |
| |
| insert into mvcctest values(NULL,'qingshan') ; insert into mvcctest values(NULL,'jack') ; commit; |
+-------------------------------------------------------------------------------------------------------+

此时的数据,创建版本是当前事务 ID,删除版本为空:

+----------+------------+------------+-----------+
| > id | > name | > 创建版本 | 删除版本 |
+==========+============+============+===========+
| > 1 | > qingshan | > 1 | undefined |
+----------+------------+------------+-----------+
| > 2 | > jack | > 1 | undefined |
+----------+------------+------------+-----------+

第二个事务,执行第 1 次查询,读取到两条原始数据,这个时候事务 ID 是 2:

+----------------------------------------------+
| Transaction 2 |
+==============================================+
| begin; |
| |
| select * from mvcctest ; -- (1) 第一次查询 |
+----------------------------------------------+

第三个事务,插入数据:

Transaction 3

begin; insert into mvcctest values(NULL,'tom') ; commit;

此时的数据,多了一条 tom,它的创建版本号是当前事务编号,3:

id name 创建版本 删除版本


1 qingshan 1 undefined
2 jack 1 undefined
3 tom 3 undefined

第二个事务,执行第 2 次查询:

Transaction 2

select * from mvcctest ; (2) 第二次查询

MVCC 的查找规则:只能查找创建时间小于等于当前事务 ID 的数据,和删除时间大于当前事务 ID 的行(或未删除)。

也就是不能查到在我的事务开始之后插入的数据,tom 的创建 ID 大于 2,所以还是只能查到两条数据。

第四个事务,删除数据,删除了 id=2 jack 这条记录:

+----------------------------------+
| Transaction 4 |
+==================================+
| begin; |
| |
| delete from mvcctest where id=2; |
+----------------------------------+

commit;

此时的数据,jack 的删除版本被记录为当前事务 ID,4,其他数据不变:

+--------+----------+----------+-------------+
| id | name | 创建版本 | > 删除版本 |
+========+==========+==========+=============+
| 1 | qingshan | 1 | > undefined |
+--------+----------+----------+-------------+
| 2 | jack | 1 | > 4 |
+--------+----------+----------+-------------+
| 3 | tom | 3 | > undefined |
+--------+----------+----------+-------------+

在第二个事务中,执行第 3 次查询:

Transaction 2

select * from mvcctest ; (3) 第三次查询

查找规则:只能查找创建时间小于等于当前事务 ID 的数据,和删除时间大于当前事务 ID 的行(或未删除)。

也就是,在我事务开始之后删除的数据,所以 jack 依然可以查出来。所以还是这两条数据。

第五个事务,执行更新操作,这个事务事务 ID 是 5:

+----------------------------------------------------------+
| Transaction 4 |
+==========================================================+
| begin; |
| |
| update mvcctest set name ='盆鱼宴' where id=1; commit; |
+----------------------------------------------------------+

此时的数据,更新数据的时候,旧数据的删除版本被记录为当前事务 ID 5(undo),产生了一条新数据,创建 ID 为当前事务 ID 5:

+--------+------------+------------+-----------+
| id | > name | > 创建版本 | 删除版本 |
+========+============+============+===========+
| 1 | > qingshan | > 1 | 5 |
+--------+------------+------------+-----------+
| 2 | > jack | > 1 | 4 |
+--------+------------+------------+-----------+
| 3 | > tom | > 3 | undefined |
+--------+------------+------------+-----------+
| 1 | > 盆鱼宴 | > 5 | undefined |
+--------+------------+------------+-----------+

第二个事务,执行第 4 次查询:

Transaction 2

select * from mvcctest ; (4) 第四次查询

查找规则:只能查找创建时间小于等于当前事务 ID 的数据,和删除时间大于当前事务 ID 的行(或未删除)。

因为更新后的数据 penyuyan 创建版本大于 2,代表是在事务之后增加的,查不出来。

而旧数据 qingshan 的删除版本大于 2,代表是在事务之后删除的,可以查出来。

通过以上演示我们能看到,通过版本号的控制,无论其他事务是插入、修改、删除,第一个事务查询到的数据都没有变化。

在 InnoDB 中,MVCC 是通过 Undo log 实现的。

Oracle、Postgres 等等其他数据库都有 MVCC 的实现。

需要注意,在 InnoDB 中,MVCC 和锁是协同使用的来实现隔离性的,这两种方案并不是互斥的。

第一大类解决方案是锁,锁又是怎么实现读一致性的呢?

2 MySQL InnoDB锁的基本类型

[https://dev.mysql.com/doc/refman/5.7/en/innodb-locking.html]

官网把锁分成了 8 类。所以我们把前面的两个行级别的锁(Shared and Exclusive

Locks),和两个表级别的锁(Intention Locks)称为锁的基本模式。

后面三个 Record Locks、Gap Locks、Next-Key Locks,我们把它们叫做锁的算法,也就是分别在什么情况下锁定什么范围。

2.1 共享锁

第一个行级别的锁就是我们在官网看到的 Shared Locks (共享锁),我们获取了一行数据的读锁以后,可以用来读取数据,所以它也叫做读锁。而且多个事务可以共享一把读锁。那怎么给一行数据加上读锁呢?

我们可以用 select …… lock in share mode; 的方式手工加上一把读锁。

释放锁有两种方式,只要事务结束,锁就会自动事务,包括提交事务和结束事务。

我们也来验证一下,看看共享锁是不是可以重复获取。

+-------------------------------------------------------+-------------------------------------------------------+
| Transaction 1 | Transaction 2 |
+=======================================================+=======================================================+
| begin; | |
+-------------------------------------------------------+-------------------------------------------------------+
| SELECT * FROM student WHERE id=1 LOCK IN SHARE MODE; | |
+-------------------------------------------------------+-------------------------------------------------------+
| | begin; |
+-------------------------------------------------------+-------------------------------------------------------+
| | SELECT * FROM student WHERE id=1 LOCK IN SHARE MODE; |
| | |
| | // OK |
+-------------------------------------------------------+-------------------------------------------------------+

2.2 排它锁

第二个行级别的锁叫做 Exclusive Locks(排它锁),它是用来操作数据的,所以又叫做写锁。只要一个事务获取了一行数据的排它锁,其他的事务就不能再获取这一行数据的共享锁和排它锁。

排它锁的加锁方式有两种,第一种是自动加排他锁,可能是同学们没有注意到的:我们在操作数据的时候,包括增删改,都会默认加上一个排它锁。

还有一种是手工加锁,我们用一个 FOR UPDATE 给一行数据加上一个排它锁,这个无论是在我们的代码里面还是操作数据的工具里面,都比较常用。

释放锁的方式跟前面是一样的。

排他锁的验证:

+-------------------------------------------------------+----------------------------------------------------------+
| Transaction 1 | Transaction 2 |
+=======================================================+==========================================================+
| begin; | |
+-------------------------------------------------------+----------------------------------------------------------+
| UPDATE student SET sname = '猫老公 555' WHERE id=1; | |
+-------------------------------------------------------+----------------------------------------------------------+
| | begin; |
+-------------------------------------------------------+----------------------------------------------------------+
| | SELECT * FROM student WHERE id=1 LOCK IN SHARE MODE; |
| | |
| | // BLOCKED |
| | |
| | SELECT * FROM student where id=1 FOR UPDATE; // BLOCKED |
| | |
| | DELETE FROM student where id=1 ; // BLOCKED |
+-------------------------------------------------------+----------------------------------------------------------+

2.3 意向锁意向锁是由数据库自己维护的。

也就是说,当我们给一行数据加上共享锁之前,数据库会自动在这张表上面加一个意向共享锁。

当我们给一行数据加上排他锁之前,数据库会自动在这张表上面加一个意向排他锁。

反过来说:

如果一张表上面至少有一个意向共享锁,说明有其他的事务给其中的某些数据行加上了共享锁。

如果一张表上面至少有一个意向排他锁,说明有其他的事务给其中的某些数据行加上了排他锁。

这两个表级别的锁存在的意义是什么?第一个,我们有了表级别的锁,在 InnoDB 里面就可以支持更多粒度的锁。第二个,如果说没有意向锁的话,当我们准备给一张表加上表锁的时候,是不是必须先要去判断有没其他的事务锁定了其中了某些行?如果有的话,肯定不能加上表锁。那么这个时候我们就要去扫描整张表才能确定能不能成功加上一个表锁,如果数据量特别大,比如有上千万的数据的时候,加表锁的效率是不是很低?

但是我们引入了意向锁之后就不一样了。只要判断这张表上面有没有意向锁,如果有,就直接返回失败。如果没有,就可以加锁成功。所以 InnoDB 里面的表锁,我们可以把它理解成一个标志。就像火车上厕所有没有人使用的灯,是用来提高加锁的效率的。

+-----------------------------------------------+---------------------------------------+
| Transaction 1 | Transaction 2 |
+===============================================+=======================================+
| begin; | |
+-----------------------------------------------+---------------------------------------+
| SELECT * FROM student where id=1 FOR UPDATE; | |
+-----------------------------------------------+---------------------------------------+
| | BEGIN; |
+-----------------------------------------------+---------------------------------------+
| | LOCK TABLES student WRITE; // BLOCKED |
| | |
| | UNLOCK TABLES; // 释放表锁的方式 |
+-----------------------------------------------+---------------------------------------+

3 行锁的原理

3.1 没有索引的表(假设锁住记录)

首先我们有三张表,一张没有索引的 t1,一张有主键索引的 t2,一张有唯一索引的 t3。

我们先假设 InnoDB 的锁锁住了是一行数据或者一条记录。

我们先来看一下 t1 的表结构,它有两个字段,int 类型的 id 和 varchar 类型的 name。

里面有 4 条数据,1、2、3、4。

+-------------------------------------------+------------------------------------------------------------+
| Transaction 1 | > Transaction 2 |
+===========================================+============================================================+
| begin; | |
+-------------------------------------------+------------------------------------------------------------+
| SELECT * FROM t1 WHERE id =1 FOR UPDATE; | |
+-------------------------------------------+------------------------------------------------------------+
| | > select * from t1 where id=3 for update; |
| | > |
| | > //blocked |
+-------------------------------------------+------------------------------------------------------------+
| | > INSERT INTO t1

(, name

) VALUES (5, '5'); |
| | > |
| | > //blocked |
+-------------------------------------------+------------------------------------------------------------+

现在我们在两个会话里面手工开启两个事务。

在第一个事务里面,我们通过 where id =1 锁住第一行数据。

在第二个事务里面,我们尝试给 id=3 的这一行数据加锁。

这个加锁的操作被阻塞了。为什么第一个事务锁住了 id=1 的这行数据,我不能操作 id=3 的数据呢?

再来操作一条不存在的数据,插入 id=5。它也被阻塞了。实际上这里整张表都被锁住了。所以,我们的第一个猜想被推翻了,InnoDB 的锁锁住的应该不是 Record。为什么在没有索引或者没有用到索引的情况下,会锁住整张表?这个问题我们先留在这里。

3.2 有主键索引的表

我们看一下 t2 的表结构。字段是一样的,不同的地方是 id 上创建了一个主键索引。里面的数据是 1、4、7、10。

+------------------------------------------+-------------------------------------------------------+
| Transaction 1 | > Transaction 2 |
+==========================================+=======================================================+
| begin; | |
+------------------------------------------+-------------------------------------------------------+
| select * from t2 where id=1 for update; | |
+------------------------------------------+-------------------------------------------------------+
| | > select * from t2 where id=1 for update; // blocked |
+------------------------------------------+-------------------------------------------------------+
| | > select * from t2 where id=4 for update; // OK |
+------------------------------------------+-------------------------------------------------------+

第一种情况,使用相同的 id 值去加锁,冲突;使用不同的 id 加锁,可以加锁成功。

那么,既然不是锁定一行数据,有没有可能是锁住了 id 的这个字段呢?我们继续往下验证。

3.3 唯一索引(假设锁住字段)

我们看一下 t3 的表结构。字段还是一样的, id 上创建了一个主键索引,name 上创建了一个唯一索引。里面的数据是 1、4、7、10。

+-------------------------------------------------+---------------------------------------------------------+
| Transaction 1 | > Transaction 2 |
+=================================================+=========================================================+
| begin; | |
+-------------------------------------------------+---------------------------------------------------------+
| select * from t3 where name= '4' for update; | |
+-------------------------------------------------+---------------------------------------------------------+
| | > select * from t3 where name = '4' for update; |
| | > |
| | > // blocked |
+-------------------------------------------------+---------------------------------------------------------+
| | > select * from t3 where id = 4 for update; // blocked |
+-------------------------------------------------+---------------------------------------------------------+

在第一个事务里面,我们通过 name 字段去锁定值是 4 的这行数据。

在第二个事务里面,尝试获取一样的排它锁,肯定是失败的。

在这里我们怀疑 InnoDB 锁住的是字段,所以换一个字段,用 id=4 去给这行数据加锁。又被阻塞了,说明锁住的是字段的这个推测也是错的,否则就不会出现第一个事务锁住了 name,第二个字段锁住 id 失败的情况。

既然锁住的不是 record,也不是 column,InnoDB 里面锁住的到底是什么呢?在这三个案例里面,我们要去分析一下他们的差异在哪里,也就是这三张表的结构,是什么区别导致了加锁的行为的差异?其实答案就是索引。InnoDB 的行锁,就是通过锁住索引来实现的。

那么我们还有两个问题没有解决:

1、为什么表里面没有索引的时候,锁住一行数据会导致锁表?或者说,如果锁住的是索引,一张表没有索引怎么办?所以,一张表有没有可能没有索引?

  1. 如果我们定义了主键(PRIMARY KEY),那么 InnoDB 会选择主键作为聚集索引。
  2. 如果没有显式定义主键,则 InnoDB 会选择第一个不包含有 NULL 值的唯一索引作为主键索引。
  3. 如果也没有这样的唯一索引,则 InnoDB 会选择内置 6 字节长的 ROWID 作为隐藏的聚集索引,它会随着行记录的写入而主键递增。

所以,为什么锁表,是因为查询没有使用索引,会进行全表扫描,然后把每一个隐藏的聚集索引都锁住了。

2、为什么通过唯一索引给数据行加锁,主键索引也会被锁住?

大家还记得在 InnoDB 里面,当我们使用辅助索引的时候,它是怎么检索数据的吗?辅助索引的叶子节点存储的是什么内容?在辅助索引里面,索引存储的是二级索引和主键的值。比如name=4,存储的是name 的索引和主键 id 的值 4。

而主键索引里面除了索引之外,还存储了完整的数据。所以我们通过辅助索引锁定一行数据的时候,它跟我们检索数据的步骤是一样的,会通过主键值找到主键索引,然后也锁定。

4 锁的算法

t2 这张表有一个主键索引。

我们插入了 4 行数据,主键 id 分别是 1、4、7、10。

因为我们用主键索引加锁,我们这里的划分标准就是主键索引的值。

这些数据库里面存在的主键值,我们把它叫做 Record,记录,那么这里我们就有 4 个 Record。

根据主键,这些存在的 Record 隔开的数据不存在的区间,我们把它叫做 Gap,间隙,它是一个左开右开的区间。

假设我们有 N 个 Record,那么所有的数据会被划分成多少个 Gap 区间?答案是

N+1,就像我们把一条绳子砍 N 刀,它最后肯定是变成 N+1 段。

最后一个,间隙(Gap)连同它左边的记录(Record),我们把它叫做临键的区间,它是一个左开右闭的区间。

4.1 记录锁

第一种情况,当我们对于唯一性的索引(包括唯一索引和主键索引)使用等值查询,精准匹配到一条记录的时候,这个时候使用的就是记录锁。

比如 where id = 1 4 7 10 。

我们使用不同的 key 去加锁,不会冲突,它只锁住这个 record。

4.2 间隙锁

第二种情况,当我们查询的记录不存在,没有命中任何一个 record,无论是用等值查询还是范围查询的时候,它使用的都是间隙锁。

举个例子,where id >4 and id <7,where id = 6。

Transaction 1 Transaction 2


begin;
INSERT INTO t2

(, name) VALUES (5, '5'); // BLOCKED INSERT INTO t2 (, name) VALUES (6, '6'); // BLOCKED select * from t2 where id =6 for update; // OK
select * from t2 where id >20 for update;
INSERT INTO t2 (, name

) VALUES (11, '11'); // BLOCKED

注意,间隙锁主要是阻塞插入 insert。相同的间隙锁之间不冲突。

Gap Lock 只在 RR 中存在,如果要关闭间隙锁,就是把事务隔离级别设置成 RC,并且把 innodb_locks_unsafe_for_binlog 设置为 ON。

这种情况下除了外键约束和唯一性检查会加间隙锁,其他情况都不会用间隙锁。

4.3 临键锁

第三种情况,当我们使用了范围查询,不仅仅命中了 Record 记录,还包含了 Gap 间隙,在这种情况下我们使用的就是临键锁,它是 MySQL 里面默认的行锁算法,相当于记录锁加上间隙锁。

唯一性索引,等值查询匹配到一条记录的时候,退化成记录锁。

没有匹配到任何记录的时候,退化成间隙锁。

比如我们使用>5 <9, 它包含了记录不存在的区间,也包含了一个 Record 7。

+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Transaction 1 | Transaction 2 |
+========================================================+===============================================================================================================================================================================================+
| begin; | |
+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| select * from t2 where id >5 and id < 9 for update; | |
+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | begin; |
+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| | select * from t2 where id =4 for update; // OK |
| | |
| | INSERT INTO t2

(, name) VALUES (6, '6'); // BLOCKED INSERT INTO t2 (, name

) VALUES (8, '8'); // BLOCKED select * from t2 where id =10 for update; // BLOCKED |
+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

临键锁,锁住最后一个 key 的下一个左开右闭的区间。

select * from t2 where id >5 and id <=7 for update; — 锁住(4,7]和(7,10] select * from t2 where id >8 and id <=10 for update; — 锁住 (7,10],(10,+∞)

为什么要锁住下一个左开右闭的区间?——就是为了解决幻读的问题。

4.4 小结:隔离级别的实现

所以,我们再回过头来看下这张图片,为什么 InnoDB 的 RR 级别能够解决幻读的

问题,就是用临键锁实现的。我们再回过头来看下这张图片,这个就是MySQL InnoDB里面事务隔离级别的实现。

最后我们来总结一下四个事务隔离级别的实现:

4.4.1Read Uncommited

RU 隔离级别:不加锁。

4.4.2Serializable

Serializable 所有的 select 语句都会被隐式的转化为 select … in share mode,会

和 update、delete 互斥。

这两个很好理解,主要是 RR 和 RC 的区别?

4.4.3Repeatable Read

RR 隔离级别下,普通的 select 使用快照读(snapshot read),底层使用 MVCC 来实现。

加锁的 select(select … in share mode / select … for update)以及更新操作

update, delete 等语句使用当前读(current read),底层使用记录锁、或者间隙锁、临键锁。

4.4.4Read Commited

RC 隔离级别下,普通的 select 都是快照读,使用 MVCC 实现。加锁的 select 都使用记录锁,因为没有 Gap Lock。除了两种特殊情况——外键约束检查(foreign-key constraint checking)以及重复

键检查(duplicate-key checking)时会使用间隙锁封锁区间。所以 RC 会出现幻读的问题。

作者:周鑫磊

来源:https://www.sparksys.top/archives/31


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (1)