文章目录
锁
从数据操作的类型划分:读锁,写锁
读锁
:也称为共享锁
、英文用S
表示。针对同一份数据,多个事务的读操作可以同时进行而不会互相影响,相互不阻塞的。写锁
:也称为排他锁
、英文用X
表示。当前写操作没有完成前,它会阻断其他写锁和读锁。这样就能确保在给定的时间里,只有一个事务能执行写入,并防止其他用户读取正在写入的同一资源。
需要注意的是对于 InnoDB 引擎来说,读锁和写锁可以加在表上,也可以加在行上
从数据操作的粒度划分:表级锁、页级锁、行锁
表级锁
表级别的S锁和X锁
在对某个表执行SELECT、INSERT、DELETE、UPDATE语句时,InnoDB存储引擎是不会
为这个表添加表级
别的 S锁
或者 X锁
的。
在对某个表执行一些诸如 ALTER TABLE
、 DROP TABLE
这类的 DDL
语句时,其他事务对这个表并发执行诸如SELECT、INSERT、DELETE、UPDATE的语句会发生阻塞。同理,某个事务中对某个表执行SELECT、INSERT、DELETE、UPDATE语句时,在其他会话中对这个表执行DDL
语句也会发生阻塞。这个过程其实是通过在 server层 使用一种称之为 元数据锁 (英文名: Metadata Locks ,简称 MDL )
结构来实现的。
一般情况下,不会使用InnoDB存储引擎提供的表级别的 S锁
和 X锁
。InnoDB的厉害之处还是实现了更细粒度的 行锁
。
意向锁
InnoDB 支持 多粒度锁(multiple granularity locking)
,它允许 行级锁
与 表级锁
共存,而意向锁就是其中的一种 表锁
。
意向锁分为两种:
- 意向共享锁(IS锁):事务有意向对表中的某些行加
共享锁
(S锁) - 意向排他锁(IX锁):事务有意向对表中的某些行加
排他锁
(X锁)
意向锁不会与行级的共享 / 排他锁互斥!正因为如此,意向锁并不会影响到多个事务对不同数据行加排他锁时的并发性。
元数据锁(MDL锁)
当对一个表做增删改查操作的时候,加 MDL读锁;当要对表做结构变更操作的时候,加 MDL 写锁。(自动加锁)
记录锁是有S锁和X锁之分的,称之为 S型记录锁
和 X型记录锁
。
- 当一个事务获取了一条记录的S型记录锁后,其他事务也可以继续获取该记录的S型记录锁,但不可以继续获取X型记录锁;
- 当一个事务获取了一条记录的X型记录锁后,其他事务既不可以继续获取该记录的S型记录锁,也不可以继续获取X型记录锁。
行级锁
记录锁(Record Locks)
记录锁也就是仅仅把一条记录锁上,官方的类型名称为: LOCK_REC_NOT_GAP 。比如我们把id值为8的那条记录加一个记录锁的示意图如图所示。仅仅是锁住了id值为8的记录,对周围的数据没有影响。
间隙锁(Gap Locks)
MySQL 在 REPEATABLE READ
隔离级别下是可以解决幻读问题的,解决方案有两种,可以使用 MVCC 方案解决
,也可以采用 加锁 方案解决
。但是在使用加锁方案解决时有个大问题,就是事务在第一次执行读取操作时,那些幻影记录尚不存在,我们无法给这些 幻影记录
加上 记录锁
。InnoDB提出了一种称之为Gap Locks
的锁,官方的类型名称为: LOCK_GAP ,我们可以简称为gap锁
。
临键锁(Next-Key Locks)
有时候我们既想锁住某条记录
,又想 阻止
其他事务在该记录前边的间隙插入新记录
,所以InnoDB就提出了一种称之为 Next-Key Locks 的锁,官方的类型名称为: LOCK_ORDINARY ,我们也可以简称为next-key锁 。Next-Key Locks是在存储引擎 InnoDB
、事务级别在 可重复读
的情况下使用的数据库锁,InnoDB 默认的锁
就是Next-Key locks
插入意向锁(Insert Intention Locks)
我们说一个事务在 插入
一条记录时需要判断一下插入位置是不是被别的事务加了gap锁
( next-key锁也包含 gap锁 ),如果有的话,插入操作需要等待,直到拥有gap锁
的那个事务提交
。但是InnoDB规定事务在等待的时候也需要在内存中生成一个锁结构,表明有事务想在某个 间隙
中 插入
新记录,但是现在在等待。InnoDB就把这种类型的锁命名为 Insert Intention Locks
,官方的类型名称为:LOCK_INSERT_INTENTION
,我们称为 插入意向锁
。插入意向锁是一种 Gap锁
,不是意向锁,在insert操作时产生。
插入意向锁是在插入一条记录行前,由 INSERT 操作产生的一种间隙锁 。事实上插入意向锁并不会阻止别的事务继续获取该记录上任何类型的锁。
页锁
页锁就是在 页的粒度
上进行锁定,锁定的数据资源比行锁要多,因为一个页中可以有多个行记录。当我们使用页锁的时候,会出现数据浪费的现象,但这样的浪费最多也就是一个页上的数据行。页锁的开销介于表锁和行锁之间,会出现死锁
。锁定粒度介于表锁和行锁之间,并发度一般
。
从对待锁的态度划分:乐观锁、悲观锁
悲观锁(Pessimistic Locking)
悲观锁是一种思想,顾名思义,就是很悲观,对数据被其他事务的修改持保守态度,会通过数据库自身的锁机制来实现,从而保证数据操作的排它性。
悲观锁总是假设最坏的情况,每次去拿数据的时候都认为别人会修改
,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会 阻塞
直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁,当其他线程想要访问数据时,都需要阻塞挂起。Java中 synchronized
和 ReentrantLock
等独占锁就是悲观锁思想的实现
乐观锁(Optimistic Locking)
乐观锁认为对同一数据的并发操作不会总发生
,属于小概率事件
,不用每次都对数据上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,也就是不采用数据库自身的锁机制,而是通过程序来实现。在程序上,我们可以采用 版本号机制
或者 CAS机制
实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量。在Java中 java.util.concurrent.atomic
包下的原子变量类就是使用了乐观锁的一种实现方式:CAS实现的。
按加锁的方式划分:显式锁、隐式锁
显示锁
通过特定的语句进行加锁:
select .... lock in share mode#加共享锁
select .... for update#加排他锁
隐式锁
- 情景一:对于
聚簇索引
记录来说,有一个trx_id
隐藏列,该隐藏列记录着最后改动该记录的事务id
。那么如果在当前事务中新插入一条聚簇索引记录后,该记录的trx_id
隐藏列代表的的就是当前事务的事务id
,如果其他事务此时想对该记录添加S锁
或者X锁
时,首先会看一下该记录的trx_id
隐藏列代表的事务是否是当前的活跃事务
,如果是的话,那么就帮助当前事务创建一个X锁
(也就是为当前事务创建一个锁结构,is_waiting
属性是false
),然后自己进入等待状态(也就是为自己也创建一个锁结构,is_waiting
属性是true
)。 - 情景二:对于
二级索引
记录来说,本身并没有trx_id
隐藏列,但是在二级索引页面的PageHeader
部分有一个PAGE_MAX_TRX_ID
属性,该属性代表对该页面做改动的最大的事务id
,如果PAGE_MAX_TRX_ID
属性值小于当前最小的活跃事务id
,那么说明对该页面做修改的事务都已经提交了,否则就需要在页面中定位到对应的二级索引记录,然后回表找到它对应的聚簇索引记录,然后再重复情景一
的做法。
MVCC(多版本并发控制)
什么是MVCC
MVCC (Multiversion Concurrency Control),多版本并发控制。顾名思义,MVCC 是通过数据行的多个版本管理
来实现数据库的并发控制
。这项技术使得在InnoDB的事务隔离级别下执行 一致性读
操作有了保证。换言之,就是为了查询一些正在被另一个事务更新的行,并且可以看到它们被更新之前的值,这样在做查询的时候就不用等待另一个事务释放锁。
快照读和当前读
MVCC在MySQL InnoDB中的实现主要是为了提高数据库并发性能,用更好的方式去处理 读-写冲突
,做到即使有读写冲突时,也能做到 不加锁
, 非阻塞并发读
,而这个读指的就是 快照读
, 而非 当前读
。当前读实际上是一种加锁的操作,是悲观锁的实现。而MVCC本质是采用乐观锁思想的一种方式。
快照读
快照读又叫一致性读,读取的是快照数据。不加锁的简单的 SELECT 都属于快照读,即不加锁的非阻塞读;
快照读的前提是隔离级别不是串行级别,串行级别下的快照读会退化成当前读。
当前读
当前读读取的是记录的最新版本(最新数据,而不是历史版本的数据),读取时还要保证其他并发事务不能修改当前记录,会对读取的记录进行加锁。加锁的 SELECT,或者对数据进行增删改都会进行当前读。
由上图可以看到,MySQL InnoDB利用MVCC实现了在可重复读的隔离级别下避免幻读的问题,这也是InnoDB引擎的强大之处.
MVCC实现原理之ReadView
MVCC的实现依赖于:隐藏字段
,Undo Log
,Read View
.
什么是ReadView
Readview
就是事务在使用MVCC机制进行快照读操作时产生的读视图
。当事务启动时,会生成数据库系统当前的一个快照。InnoD8 为每个事务构造了一个数组,用来记录并维护系统当前 活跃事务
的ID(“活跃”指的就是,启动了但还没提交)。
设计思路
使用 READ UNCOMMITTED
隔离级别的事务,由于可以读到未提交事务修改过的记录(脏读),所以直接读取记录的最新版本就好了。
使用 SERIALIZABLE
隔离级别的事务,InnoDB规定使用加锁的方式来访问记录。
使用READ COMMITTED
和 REPEATABLE READ
隔离级别的事务,都必须保证读到 已经提交了的
事务修改过的记录。假如另一个事务已经修改了记录但是尚未提交,是不能直接读取最新版本的记录的,核心问题就是需要判断一下版本链中的哪个版本是当前事务可见的,这是ReadView要解决的主要问题。
这个ReadView中主要包含4个比较重要的内容,分别如下:
creator_trx_id
,创建这个 Read View 的事务 ID。trx_ids
,表示在生成ReadView时当前系统中活跃的读写事务的事务id列表
。up_limit_id
,活跃的事务中最小的事务 ID。low_limit_id
,表示生成ReadView时系统中应该分配给下一个事务的 id 值。low_limit_id
是系统最大的事务id值+1,这里要注意是系统中的事务id,需要区别于正在活跃的事务ID。
ReadView的规则
有了这个ReadView,这样在访问某条记录时,只需要按照下边的步骤判断记录的某个版本是否可见。
- 如果被访问版本的
trx_id
属性值与ReadView中的creator_trx_id
值相同,意味着当前事务在访问它自己修改过的记录,所以该版本可以被当前事务访问。 - 如果被访问版本的
trx_id
属性值小于
ReadView中的up_limit_id
值,表明生成该版本的事务在当前事务生成ReadView前已经提交,所以该版本可以被当前事务访问。 - 如果被访问版本的
trx_id
属性值大于或等于
ReadView中的low_limit_id
值,表明生成该版本的事务在当前事务生成ReadView后才开启,所以该版本不可以被当前事务访问。 - 如果被访问版本的trx_id属性值在ReadView的
up_limit_id
和low_limit_id
之间,那就需要判断一下trx_id
属性值是不是在trx_ids
列表中。- 如果在,说明创建ReadView时生成该版本的事务还是活跃的,该版本不可以被访问。
- 如果不在,说明创建ReadView时生成该版本的事务已经被提交,该版本可以被访问。
MVCC不同隔离级别的区别
在隔离级别为读已提交(Read Committed)时,一个事务中的每一次 SELECT 查询都会重新获取一次Read View。
当隔离级别为可重复读的时候,就避免了不可重复读,这是因为一个事务只在第一次 SELECT 的时候会获取一次 Read View,而后面所有的 SELECT 都会复用这个 Read View,如下表所示:
举例说明
READ COMMITTED隔离级别下
假设现在有两个事务id
分别为10
,20
的事务在执行:
# Transaction 10
BEGIN;
UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;
# Transaction 20
BEGIN;
# 更新了一些别的表的记录
...
此刻,表student 中id
为 1
的记录得到的版本链表如下所示:
假设现在有一个使用READ COMMITTED
隔离级别的事务开始执行:
# 使用READ COMMITTED隔离级别的事务
BEGIN;
# SELECT1:Transaction 10、20未提交
SELECT * FROM student WHERE id = 1; # 得到的列name的值为'张三'
这个SELECT
的执行过程如下:
步骤1:在执行SELECT
语句时会生成一个ReadView
,他的trx_ids
列表的内容就是[10,20]
,up_limit_id
就是10
,low_limit_id
为21
,creator_trx_id
为0
.
步骤2.3:从版本链中可以看到最新的列name
的内容是王五
,该版本的trx_id
值为10
,在trx_ids
列表内,所以不符合可见性要求,根据roll_pointer
跳转到下一个版本.同理李四
也不符合要求,再次跳转
步骤4:张三
版本的trx_id
为8
,小于ReadView
中的up_limit_id
值10
,所以这个版本符合要求,最后可以展示.
之后,我们把事务id
为10
的事务提交一下:
# Transaction 10
BEGIN;
UPDATE student SET name="李四" WHERE id=1;
UPDATE student SET name="王五" WHERE id=1;
COMMIT;
然后再到 事务id
为 20
的事务中更新一下表 student 中 id
为1
的记录:
# Transaction 20
BEGIN;
# 更新了一些别的表的记录
...
UPDATE student SET name="钱七" WHERE id=1;
UPDATE student SET name="宋八" WHERE id=1;
此刻,表student中 id 为 1 的记录的版本链就长这样:
然后再到刚才使用 READ COMMITTED
隔离级别的事务中继续查找这个 id
为 1
的记录,如下:
# 使用READ COMMITTED隔离级别的事务
BEGIN;
# SELECT1:Transaction 10、20均未提交
SELECT * FROM student WHERE id = 1; # 得到的列name的值为'张三'
# SELECT2:Transaction 10提交,Transaction 20未提交
SELECT * FROM student WHERE id = 1; # 得到的列name的值为'王五'
这个SELECT
的执行过程如下:
步骤1:在执行SELECT
语句的时候会单独生成一个ReadView
,他的trx_ids
列表的内容就是[20]
,up_limit_id
就是20
,low_limit_id
为21
,creator_trx_id
为0
.
步骤2,3:从版本链中可以看到最新的列name
的内容是宋八
,该版本的trx_id
值为20
,在trx_ids
列表内,所以不符合可见性要求,根据roll_pointer
跳转到下一个版本.同理钱七
也不符合要求,再次跳转.
步骤4:王五
版本的trx_id
为10
,小于ReadView
中的up_limit_id
值20
,所以这个版本符合要求,最后可以展示.
可以看到,这就发生了可重复读的问题了.
REPEATABLE READ隔离级别下
使用 REPEATABLE READ
隔离级别的事务来说,只会在第一次执行查询语句时生成一个 ReadView
,之后的查询就不会重复生成了。
对于刚才的例子:
# 使用REPEATABLE READ隔离级别的事务
BEGIN;
# SELECT1:Transaction 10、20均未提交
SELECT * FROM student WHERE id = 1; # 得到的列name的值为'张三'
# SELECT2:Transaction 10提交,Transaction 20未提交
SELECT * FROM student WHERE id = 1; # 得到的列name的值仍为'张三'
现在需要解答的问题是为什么第二次查询的结果还是张三
呢?
这是因为当前事务的隔离级别为可重复读
,而之前在执行SELECT1
的时候已经生成过ReadView
了,所以直接复用之前的ReadView
,之前的ReadView
的trx_ids
列表的内容就是[10,20]
,up_limit_id
就是10
,low_limit_id
为21
,creator_trx_id
为0
.
接下的分析过程与上面的类似了,所以最终得到的结果为张三
.
如何解决幻读?
假设现在表 student 中只有一条数据,数据内容中,主键 id=1
,隐藏的 trx_id=10
,它的 undo log
如下图所示
假设现在有事务 A 和事务 B 并发执行, 事务 A 的事务 id
为 20
, 事务 B 的事务id
为 30
。
步骤1:事务 A 开始第一次查询数据,查询的 SQL 语句如下。
select * from student where id >= 1;
在开始查询之前,MySQL 会为事务 A 产生一个 ReadView
,此时 ReadView
的内容如下:trx_ids=[20,30]
, up_limit_id=20
,low_limit_id=31
, creator_trx_id=20
。
步骤2:接着事务 B(trx_id
=30),往表 student 中新插入两条数据,并提交事务。
insert into student(id,name) values(2,'李四');
insert into student(id,name) values(3,'王五');
此时表student 中就有三条数据了,对应的 undo 如下图所示:
步骤3:接着事务 A 开启第二次查询,根据可重复读隔离级别的规则,此时事务 A 并不会再重新生成ReadView。此时表 student 中的 3 条数据都满足 where id>=1 的条件,因此会先查出来。然后根据ReadView 机制,判断每条数据是不是都可以被事务 A 看到。
1)首先 id=1 的这条数据,前面已经说过了,可以被事务 A 看到。
2)然后是 id=2 的数据,它的 trx_id
=30,此时事务 A 发现,这个值处于 up_limit_id
和 low_limit_id
之间,因此还需要再判断 30 是否处于 trx_ids
数组内。由于事务 A 的 trx_ids=[20,30]
,因此在数组内,这表示 id=2 的这条数据是与事务 A 在同一时刻启动的其他事务提交的,所以这条数据不能让事务 A 看到。
3)同理,id=3 的这条数据,trx_id 也为 30,因此也不能被事务 A 看见。
总结
这里介绍了 MVCC
在 READ COMMITTD
、 REPEATABLE READ
这两种隔离级别的事务在执行快照读操作时访问记录的版本链的过程。这样使不同事务的 读-写 、 写-读 操作并发执行,从而提升系统性能。
核心点在于ReadView
的原理, READ COMMITTD
、 REPEATABLE READ
这两个隔离级别的一个很大不同就是生成ReadView的时机不同:
READ COMMITTD
在每一次
进行普通SELECT操作前都会生成一个
ReadViewREPEATABLE READ
只在第一次
进行普通SELECT操作前生成一个ReadView
,之后的查询操作都重复使用
这个ReadView
就好了。