MySQL 【读写锁+表锁+行锁+MVCC】

本文整理自尚硅谷MySQL数据库教程天花板

写在前面：
简单的思维导图：
并发的事务会导致数据不一致问题(脏写脏读等) ->
引申出四种隔离级别(解决问题的方案) ->
隔离级别由redo log + undo log +锁+MVCC共同实现（解决问题的工具）

文章目录

• • • 锁
    • • 并发事务访问相同记录的三种情况：
      • 并发问题的解决方案
    • 锁的不同角度分类
    • • 对数据 *** 作类型划分：
      • 锁粒度角度划分：
      • 锁的态度划分：
      • 加锁方式划分：
      • 其他：
    • 读锁、写锁
    • • 锁定读
      • 表级锁、页级锁、行锁
      • • 表锁（Table Lock）
        • • 意向锁 （intention lock）
          • 自增锁（AUTO-INC锁）
          • 元数据锁（MDL锁）
        • 行锁
        • • 记录锁（Record Locks）
          • 间隙锁（Gap Locks）
          • 临键锁（Next-Key Locks）
          • 插入意向锁（Insert Intention Locks）
        • 页锁
    • 乐观锁
    • 悲观锁
    • 全局锁
    • 死锁
    • MVCC多版本控制
    • • 快照读与当前读
      • 快照读
      • 当前读
    • MVCC原理（隐藏字段、Undo Log版本链、ReadView）
    • • 隐藏字段、Undo Log版本链
      • ReadView
    • 对MySQL幻读隔离级别的思考：

锁

为保证数据的一致性，需要对并发 *** 作进行控制 ，因此产生了锁 。同时锁机制也为实现MySQL 的各个隔离级别提供了保证。 锁冲突也是影响数据库并发访问性能的一个重要因素。所以锁对数据库而言显得尤其重要，也更加复杂。

并发事务访问相同记录的三种情况：

• 读-读情况

  即并发事务相继读取相同的记录 。读取 *** 作本身不会对记录有任何影响，并不会引起什么问题，所以允许这种情况的发生。

• 写-写情况

  即并发事务相继对相同的记录做出改动。 在这种情况下会发生脏写的问题，任何一种隔离级别都不允许这种问题的发生。所以在多个未提交事务相继对一条记录做改动时，需要让它们 排队执行 ，这个排队的过程其实是通过 锁 来实现的。

• 读-写 或 写-读

  即一个事务进行读取 *** 作，另一个进行改动 *** 作。这种情况下可能发生脏读、不可重复读、幻读的问题。以上问题可以通过MVCC解决，也可通过锁解决。

并发问题的解决方案

怎么解决脏读、不可重复读、幻读这些问题呢？

有两种可选的解决方案：

• 方案一：读 *** 作利用MVCC，写 *** 作进行加锁 。

  普通的SELECT语句在READ COMMITTED和REPEATABLE READ隔离级别下会使用到MVCC读取记录。 在 READ COMMITTED 隔离级别下，一个事务在执行过程中每次执行SELECT *** 作时都会生成一 个ReadView，ReadView的存在本身就保证了事务不可以读取到未提交的事务所做的更改 ，也就是避免了脏读现象； 在 REPEATABLE READ 隔离级别下，一个事务在执行过程中只有第一次执行SELECT *** 作 才会生成一个ReadView，之后的SELECT *** 作都复用这个ReadView，这样也就避免了不可重复读和幻读的问题。

• 方案二：读、写 *** 作都采用加锁的方式，但这种方式并发度低。

• 小结对比发现： 采用 MVCC 方式的话， 读-写 *** 作彼此并不冲突， 性能更高 。 采用 加锁 方式的话， 读-写 *** 作彼此需要 排队执行 ，影响性能。 一般情况下我们当然愿意采用 MVCC 来解决 读-写 *** 作并发执行的问题，但是业务在某些特殊情况 下，要求必须采用 加锁 的方式执行。

锁的不同角度分类 对数据 *** 作类型划分：

S（share lock 共享锁/读锁）与 X（exclusive lock 排他锁/写锁）

锁粒度角度划分：

表级锁、行级锁、页级锁

表级锁又分为：表级别的S，X锁、意向锁、自增锁、MDL锁

行级锁又分为：record locks 记录锁、Gap Locks 间隙锁、Next-Key Locks、插入意向锁

锁的态度划分：

悲观锁、乐观锁

加锁方式划分：

显示锁、隐式锁

其他：

全局锁、死锁

读锁、写锁

• 读锁 ：也称为共享锁 、英文用 S 表示。针对同一份数据，多个事务的读 *** 作可以同时进行而不会互相影响，相互不阻塞的。

• 写锁 ：也称为排他锁 、英文用 X 表示。当前写 *** 作没有完成前，它会阻断其他写锁和读锁。这样就能确保在给定的时间里，只有一个事务能执行写入，并防止其他用户读取正在写入的同一资源。 需要注意的是对于 InnoDB 引擎来说，读锁和写锁可以加在表上，也可以加在行上。

锁定读

1. 加S锁

   在采用加锁方式解决脏读、不可重复读、幻读这些问题时，读取一条记录时需要获取该记录的S锁，其实是不严谨的，有时候需要在读取记录时就获取记录的X锁，来禁止别的事务读写该记录，可对读取的记录加S锁：SELECT ... LOCK IN SHARE MODE;

   在普通的SELECT语句后边加LOCK IN SHARE MODE，如果当前事务执行了该语句，那么会对已读取到的记录加S锁，这样允许别的事务继续获取这些记录的S锁(比方说别的事务也使用SELECT …LOCK IN SHAREMODE 语句来读取这些记录)，但是不能获取这些记录的X锁(比如使用SELECT … FOR UPDATE语句来读取这些记录，或者直接修改这些记录)。如果别的事务想要获取这些记录的X锁，那么它们会阻塞，直到当前事务提交之后将这些记录上的S锁释放掉。

2. 加X锁

   对读取的记录加X锁：SELECT ... FOR UPDATE，在普通的SELECT语句后边加FOR UPDATE，如果当前事务执行了该语句，那么它会为读取到的记录加X锁，这样既不允许别的事务获取这些记录的S锁(比方说别的事务使用SELECT … LOCK IN SHARE MODE语句来读取这些记录)，也不允许获取这些记录的X锁(比如使用SELECT … FOR UPDATE语句来读取这些记录，或者直接修改这些记录)。如果别的事务想要获取这些记录的S锁或者X锁，那么它们会阻塞，直到当前事务提交之后将这些记录上的X锁释放掉。

表级锁、页级锁、行锁 表锁（Table Lock）

1. 表级别的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存储引擎提供的表t 的 S锁 或者 X锁 可以这么写：

   • LOCK TABLES t READ ：InnoDB存储引擎会对表 t 加表级别的 S锁 。

   • LOCK TABLES t WRITE ：InnoDB存储引擎会对表 t 加表级别的 X锁 。

不过尽量避免在使用InnoDB存储引擎的表上使用 LOCK TABLES 这样的手动锁表语句，它们并不会提供什么额外的保护，只是会降低并发能力而已。InnoDB的厉害之处还是实现了更细粒度的行锁 ，关于 InnoDB表级别的 S锁 和 X锁 大家了解一下就可以了。

意向锁 （intention lock）

InnoDB 支持多粒度锁（multiple granularity locking） ，它允许 行级锁 与 表级锁 共存，而意向 锁就是其中的一种表锁 。 意向锁分为两种：

• 意向共享锁（intention shared lock, IS）：事务有意向对表中的某些行加共享锁（S锁）

  -- 事务要获取某些行的 S 锁，必须先获得表的 IS 锁。
  SELECT column FROM table ... LOCK IN SHARE MODE;
  

• 意向排他锁（intention exclusive lock, IX）：事务有意向对表中的某些行加排他锁（X锁）

  -- 事务要获取某些行的 X 锁，必须先获得表的 IX 锁。
  SELECT column FROM table ... FOR UPDATE;
  

  意向锁是由存储引擎自己维护的 ，用户无法手动 *** 作意向锁，在为数据行加共享 / 排他锁之前， InooDB 会先获取该数据行所在数据表的对应意向锁 。

  不论哪种意向锁，它们直接是不互斥的。

意向锁要解决的问题：

现在有两个事务，分别是T1和T2，其中T2试图在该表级别上应用共享或排它锁，如果没有意向锁存在，那么T2就需要去检查各个页或行是否存在锁；如果存在意向锁，那么此时就会受到由T1控制的表级别意向锁的阻塞。T2在锁定该表前不必检查各个页或行锁，而只需检查表上的意向锁。

简单来说意向锁类似于一个flag标识，告诉其他事务已经有人锁定了表中的某些记录。

自增锁（AUTO-INC锁）

在使用MySQL过程中，我们可以为表的某个列添加 AUTO_INCREMENT 属性。AUTO_INCREMENT意味着在书写插入语句时不需要为该属性赋值，每次插入时会使用到自增锁。

元数据锁（MDL锁）

MySQL5.5引入了meta data lock，简称MDL锁，属于表锁范畴。MDL 的作用是保证读写的正确性。比如，如果一个查询正在遍历一个表中的数据，而执行期间另一个线程对这个表结构做变更 ，增加了一列，那么查询线程拿到的结果跟表结构对不上，肯定是不行的。

因此，当对一个表做增删改查 *** 作的时候，加MDL读锁；当要对表做结构变更 *** 作的时候，加 MDL写锁，也可理解为DDL语句加MDL读锁，DML语句加MDL写锁。

行锁 记录锁（Record Locks）

记录锁也就是仅仅把一条记录锁上，官方的类型名称为： LOCK_REC_NOT_GAP 。比如我们把id值为8的 那条记录加一个记录锁的示意图如图所示。仅仅是锁住了id值为8的记录，对周围的数据没有影响。

记录锁是有S锁和X锁之分的，称之为 S型记录锁 和 X型记录锁 。 当一个事务获取了一条记录的S型记录锁后，其他事务也可以继续获取该记录的S型记录锁，但不可以继续获取X型记录锁； 当一个事务获取了一条记录的X型记录锁后，其他事务既不可以继续获取该记录的S型记录锁，也不可以继续获取X型记录锁。

注意：对于select查询来说，只有查询时加上lock in share mode与for update才能加上行锁，普通的查询不会加上行锁；

间隙锁（Gap Locks）

MySQL 在 REPEATABLE READ 隔离级别下是可以解决幻读问题的，解决方案有两种，可以使用 MVCC 方案解决，也可以采用加锁方案解决。但是在使用加锁方案解决时有个大问题，就是事务在第一次执行读 取 *** 作时，那些幻影记录尚不存在，我们无法给这些幻影记录加上记录锁 。InnoDB提出了一种称之为 Gap Locks 的锁，官方的类型名称为： LOCK_GAP ，我们可以简称为 gap锁 。比如，把id值为8的那条记录加一个gap锁的示意图如下。

执行select * from t where id = 5 lock in share mode，图中id值为(3,8)的记录加了gap锁，意味着不允许别的事务在id值为8的记录前边的间隙插入新记录，其实就是id列的值(3, 8)这个区间的新记录是不允许立即插入的。比如，有另外一个事务再想插入一条id值为4的新记录，会被阻塞，直到拥有这个gap锁的事务提交了之后，新记录才可以被插入。

gap锁的提出仅仅是为了防止插入幻影记录而提出的。

临键锁（Next-Key Locks）

有时候我们既想锁住某条记录 ，又想阻止其他事务在该记录前边的间隙插入新记录 ，所以InnoDB就提出了一种称之为 Next-Key Locks 的锁，官方的类型名称为： LOCK_ORDINARY ，我们也可以简称为next-key锁 。Next-Key Locks是在存储引擎 innodb 、事务级别在可重复读的情况下使用的数据库锁，InnoDB默认的锁就是Next-Key locks。

-- 临键锁可理解为记录锁与间隙锁的合体
-- 以下语句会对id对3-8之间的记录加临键锁，也包含3与8，例如闭区间[3，8]
begin; 
select * from student where id <=8 and id > 3 for update;

插入意向锁（Insert Intention Locks）

我们说一个事务在插入一条记录时需要判断一下插入位置是不是被别的事务加了 gap锁 （ next-key锁也包含 gap锁 ），如果有的话，插入 *** 作需要等待，直到拥有 gap锁 的那个事务提交。但是InnoDB规定事务在等待的时候（阻塞）也需要在内存中生成一个锁结构，表明有事务想在某个间隙中插入新记录，但是现在在等待。InnoDB就把这种类型的锁命名为 Insert Intention Locks ，官方的类型名称为：LOCK_INSERT_INTENTION ，我们称插入意向锁 。插入意向锁是一种 Gap锁 ，不是意向锁，在insert *** 作时产生。

插入意向锁是在插入一条记录行前，由 INSERT *** 作产生的一种间隙锁 。

插入意向锁并不会阻止别的事务继续获取该记录上任何类型的锁。

页锁

页锁就是在页的粒度上进行锁定，锁定的数据资源比行锁要多，因为一个页中可以有多个行记录。当我们使用页锁的时候，会出现数据浪费的现象，但这样的浪费最多也就是一个页上的数据行。页锁的开销介于表锁和行锁之间，会出现死锁。锁定粒度介于表锁和行锁之间，并发度一般。

当行锁的数量超过了一定阈值，就会进行锁升级，升级为页锁。

乐观锁

乐观锁认为对同一数据的并发 *** 作不会总发生，属于小概率事件，不用每次都对数据上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，也就是不采用数据库自身的锁机制，而是通过程序来实现。在程序上，我们可以采用 版本号机制 或者 CAS机制 实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量。

例如在超卖问题上，有使用两种乐观锁的方式：

-- 第一种方式使用版本号version (使用时间戳作为版本号也可以)
select version from product where id = 1;
update product set 库存 = 库存 - 1 where id = 1 and version = #{version};

-- 第二种方式直接使用库存来判断
update product set 库存 = 库存 - 1 where id = 1 and 库存 - 1 >= 0;

悲观锁

悲观锁是一种思想，顾名思义，就是很悲观，对数据被其他事务的修改持保守态度，会通过数据库自身的锁机制来实现，从而保证数据 *** 作的排它性。

悲观锁总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会 阻塞 直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。比如行锁，表锁等，读锁，写锁等，都是在做 *** 作之前先上锁，当其他线程想要访问数据时，都需要阻塞挂起。Java中 synchronized 和 ReentrantLock 等独占锁就是悲观锁思想的实现。

例如在超卖问题上，用for update解决超卖问题：

select 库存 from product where id = 1 for update;
-- 后续 如果库存数大于0 则生成订单

全局锁

全局锁就是对整个数据库实例加锁。当你需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句。全局锁的典型使用场景 是：做 全库逻辑备份 。

全局锁的命令：Flush tables with read lock

死锁

死锁是指两个或多个事务在同一资源上相互占用，并请求锁定对方占用的资源，从而导致恶性循环。死锁示例：

-- 事务1：
start transaction; 
update account set money=10 where id=1; 
-- 事务2
start transaction; 
update account set money=10 where id=2; 
-- 事务1
update account set money=20 where id=2; 
-- 事务2
update account set money=20 where id=1;

这时候，事务1在等待事务2释放id=2的行锁，而事务2在等待事务1释放id=1的行锁。 事务1和事务2在互相等待对方的资源释放，就是进入了死锁状态。当出现死锁以后，有两种策略 ：

• 一种策略是，直接进入等待，直到超时。这个超时时间可以通过参数innodb_lock_wait_timeout 来设置，默认50秒。

• 另一种策略是，发起死锁检测，发现死锁后，主动回滚死锁链条中的某一个事务（将持有最少行级排他锁的事务进行回滚），让其他事务得以继续执行。将参数 innodb_deadlock_detect 设置为on（默认开启），表示开启这个逻辑。

第二种策略的成本分析

方法1：如果你能确保这个业务一定不会出现死锁，可以临时把死锁检测关掉。但是这种 *** 作本身带有一定的风险，因为业务设计的时候一般不会把死锁当做一个严重错误，毕竟出现死锁了，就回滚，然后通过业务重试一般就没问题了，这是 业务无损 的。而关掉死锁检测意味着可能会出现大量的超时，这是业务有损的。

方法2：控制并发度。如果并发能够控制住，比如同一行同时最多只有10个线程在更新，那么死锁检测的成本很低，就不会出现这个问题。这个并发控制要做在 数据库服务端 。如果你有中间件，可以考虑在中间件实现。

MVCC多版本控制

MVCC （Multiversion Concurrency Control），多版本并发控制。顾名思义，MVCC 是通过数据行的多个版本管理来实现数据库的并发控制 。这项技术使得在InnoDB的事务隔离级别下执行一致性读 *** 作有了保证。换言之，就是为了查询一些正在被另一个事务更新的行，并且可以看到它们被更新之前的值，这样在做查询的时候就不用等待另一个事务释放锁。

通过MVCC 我们可以解决:

1. 读写之间阻塞的问题。通过MVCC可以让读写互相不阻塞，即读不阻塞写，写不阻塞读，这样可以提升事务并发处理能力。
2. 降低了死锁的概率。这是因为MVCC采用了乐观锁的方式，读取数据时并不需要加锁，对于写 *** 作，也只锁定必要的行。
3. 解决快照读的问题。当我们查询数据在某个时间的快照时，不能看到这个时间点之后事务提交的更新结果。

快照读与当前读

MVCC在InnoDB中的实现主要是为了提高数据库并发性能，用更好的方式去处理 读-写冲突 ，做到即使有读写冲突时，也能做到 不加锁，非阻塞并发读，而这个读指的就是快照读 , 而非当前读。当前读实际上是一种加锁的 *** 作，是悲观锁的实现。而MVCC本质是采用乐观锁思想的一种方式。

快照读

快照读又叫一致性读，读取的是快照数据。不加锁的简单的 SELECT 都属于快照读，即不加锁的非阻塞读；之所以出现快照读的情况，是基于提高并发性能的考虑，快照读的实现是基于MVCC，它在很多情况下，避免了加锁 *** 作，降低了开销。

既然是基于多版本，那么快照读可能读到的并不一定是数据的最新版本，而有可能是之前的历史版本。快照读的前提是隔离级别不是串行级别，串行级别下的快照读会退化成当前读。

当前读

当前读读取的是记录的最新版本（最新数据，而不是历史版本的数据），读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。加锁的 SELECT，或者对数据进行增删改都会进行当前读。比如：

SELECT * FROM student LOCK IN SHARE MODE; # 共享锁
SELECT * FROM student FOR UPDATE; # 排他锁
INSERT INTO student values ... # 排他锁
DELETE FROM student WHERE ... # 排他锁
UPDATE student SET ... # 排他锁

MVCC原理（隐藏字段、Undo Log版本链、ReadView） 隐藏字段、Undo Log版本链

回顾一下undo日志的版本链，对于使用 InnoDB 存储引擎的表来说，它的聚簇索引记录中都包含两个必要的隐藏列。

• trx_id ：每次一个事务对某条聚簇索引记录进行改动时，都会把该事务的事务id赋值给trx_id 隐藏列。

• roll_pointer ：每次对某条聚簇索引记录进行改动时，都会把旧的版本写入到undo日志中，然后这个隐藏列就相当于一个指针，指向undo log链表，这个链表称之为 版本链 ，版本链的头节点就是当前记录最新的值。每个版本中还包含生成该版本时对应的事务id 。
  

ReadView

前提：在读已提交和可重复读的情况下，事务读数据时才会生成一个ReadView；读未提交下事务直接读取最新记录，串行化下事务直接加表级排他锁；

使用 READ COMMITTED 和 REPEATABLE READ 隔离级别的事务，都必须保证读到已经提交了的事务修改过的记录。假如另一个事务已经修改了记录但是尚未提交，是不能直接读取最新版本的记录的，核心问题就是需要判断undo log版本链中的哪个版本是当前事务可见的，这是ReadView要解决的主要问题。

ReadView中主要包含4个比较重要的id：

1. creator_trx_id：创建这个 Read View 的事务 ID。

   只有在对表中的记录做改动时（执行INSERT、DELETE、UPDATE这些语句时）才会为事务分配事务id，否则在一个只读事务中的事务id值都默认为0。

2. trx_ids：表示在生成ReadView时当前系统中活跃的读写事务的事务id列表 。

3. up_limit_id：活跃的事务中最小的事务 ID。

4. low_limit_id：表示生成ReadView时系统中应该分配给下一个事务的 id 值。low_limit_id 是系统最大的事务id值，这里要注意是系统中的事务id，需要区别于正在活跃的事务ID。

   low_limit_id并不是trx_ids中的最大值，事务id是递增分配的。比如，现在有id为1，

   2，3这三个事务，之后id为3的事务提交了。那么一个新的读事务在生成ReadView时，

   trx_ids就包括1和2，up_limit_id的值就是1，low_limit_id的值就是4

了解了这些概念之后，我们来看下当查询一条记录的时候，系统如何通过MVCC找到它：

1. 首先获取事务自己的版本号，也就是事务 ID；
2. 获取 ReadView；
3. 查询得到的数据，然后与 ReadView 中的事务版本号进行比较；
4. 如果不符合 ReadView 规则，就需要从 Undo Log 中获取历史快照；
5. 最后返回符合规则的数据。

在隔离级别为读已提交时，一个事务中的每一次 SELECT 查询都会重新获取一次Read View。

在可重复读情况下，一个事务第一次查询时会生成一个ReadView，后续查询中仍旧使用第一次生成的ReadView。

对MySQL幻读隔离级别的思考：

幻读问题（在RR级别下，Innodb是利用MVCC解决了幻读的问题，或者说部分解决幻读问题）：

-- 解决幻读问题的场景：
-- 事务1：
begin;
select * from t where data = 1; -- 结果不存在
-- 事务2：
begin;
insert into t (data,data2) values(1,1); -- 插入数据未提交
-- 事务1：
select * from t where data = 1; -- 结果不存在

-- 出现问题的场景(业务问题，不是幻读问题)：
-- 事务1：
begin;
select * from t where data = 1 and data2 = 1; -- 结果不存在
-- 事务2：
begin;
select * from t where data = 1 and data2 = 1; -- 结果不存在
insert into t (data,data2) values (1,1); -- 插入数据
commit;
-- 事务1：
insert into t (data,data2) values (1,1); -- 插入一样数据
commit;

-- 两个事务都正常执行，如果业务要求(data,data2)两列在表中是唯一的，(data,data2)两列未建立唯一联合索引，最后结果发现有两条重复数据，就会导致业务问题；
-- 解决方式可以使用 select * from t where data = 1 and data2 = 1 for update; 加写锁，但这样并发度会下降；