【MySQL数据库原理 七】MySQL数据库事务及锁机制_使用数据库事务:确保获取最大值和插入新值的操作在同一个事务内完成。 锁定行:在

事务（Transaction）是并发控制的单位，是用户定义的一个操作序列。这些操作要么都做，要么都不做，是一个不可分割的工作单位事务体现出整体的概念，要么事务中的操作全部成功，要么全部失败体现在数据库sql里就是逻辑上相互依赖的一组sql语句。
在 MySQL 中，事务支持是在引擎层实现的。MySQL 是一个支持多引擎的系统，但并不是所有的引擎都支持事务。比如 MySQL 原生的 MyISAM 引擎就不支持事务，这也是 MyISAM 被 InnoDB 取代的重要原因之一

事务的基本概念

包括事务的四大特性，并发隔离问题，通过设置事务的隔离级别解决事务的并发隔离问题。

事务的四大特性（ACID）

事务最经典也经常被拿出来说例⼦就是转账了。假如⼩明要给⼩红转账1000元，这个转账会涉及到两个关键操作就是：将⼩明的余额减少1000元，将⼩红的余额增加1000元。万⼀在这两个操作之间突然出现错误⽐如银⾏系统崩溃，导致⼩明余额减少⽽⼩红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败

事务的四大特性就是ACID，也就是原子性、一致性、隔离性以及持久性

• 原子性（Atomicity），事务是最⼩的执⾏单位，不允许分割。事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。
• 一致性（Consistency），是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。
• 隔离性（Isolation），是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离，要串行执行。即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。
• 持久性（Durability），是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，导致数据库因为故障而没有执行事务的重大错误。

只有满足这四大特性，才能说这是一个标准的事务。原子性和一致性很好理解，这是从操作状态的角度上来看的，持久性主要关注的是数据库的crash safe能力，这个由MySQL的日志机制来满足，在日志机制这篇Blog里我详细的讨论过，那么我们当前最需要关注的其实就是事务的隔离性。

并发事务的隔离问题

当多个线程都开启事务操作数据库中的数据时，数据库系统要能进行隔离操作，以保证各个线程获取数据的准确性，我们先看看如果不考虑事务的隔离性，会发生的几种问题：

脏读

脏读（dirty reads），是指在一个事务处理过程里读取了另一个未提交的事务中的数据。当⼀个事务正在访问数据并且对数据进⾏了修改，⽽这种修改还没有提交到数据库中，这时另外⼀个事务也访问了这个数据，然后使⽤了这个数据。因为这个数据是还没有提交的数据，那么另外⼀个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的

用户A向用户B转账100元，对应SQL命令如下：
update account set money=money+100 where name=’B’;  (此时A通知B)
update account set money=money - 100 where name=’A’;
1
2
3

• 当只执行第一条SQL时，A通知B查看账户，B发现确实钱已到账（此时即发生了脏读）
• 无论第二条SQL是否执行，只要该事务不提交，则所有操作都将回滚
• 当B以后再次查看账户时就会发现钱其实并没有转

也就是脏读一般针对修改数据而言，Transaction 1 修改了一行数据，然后 Transaction 2 在 Transaction 1 还未提交修改操作之前读取了被修改的行。如果 Transaction 1 回滚了修改操作，那么Transaction 2读取的数据就可以看作是从未存在过的 A未提交的修改被B读了

不可重复读

不可重复读（non-repeatable reads），针对修改，是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。A已提交的修改被B读了

A向B转账100并且提交，B收到读到100，这时候A又向B转100并提交，B读到200
1

• 在某些情况下，不可重复读并不是问题，比如我们多次查询某个数据当然以最后查询得到的结果为主
• 不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据

Transaction 1 读取一行数据，然后 Transaction 2 修改或删除该行并提交修改操作。当 Transaction 1 试图重新读取该行时，它就会得到不同的数据值（如果该行被更新）或发现该行不再存在（如果该行被删除）

幻读

幻读（phantom read）是事务非独立执行时发生的一种现象。针对插入。

• 事务T1对一个表中所有的行的某个数据项做了从1修改为2的操作
• 这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为1并且提交给数据库。
• 而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项（修改），而幻读针对的是一批数据整体（插入或删除）。A已提交的新增删除数据被B读了

综合举例

对于同一个银行帐户A内有200元，甲进行提款操作100元，乙进行转帐操作100元到B帐户。如果事务没有进行隔离可能会并发如下问题：

• 脏读：甲先取款100元未提交，乙进行转帐查到帐户内剩有100元，这时甲放弃操作回滚，乙正常操作转账至B账户提交，帐户内最终更新为0元，乙读取了甲的脏数据，客户损失100元。
  不可重复读：甲乙同时开始都查到帐户内为200元，甲先开始取款100元提交，这时乙在准备最后更新的时候又进行了一次查询，发现结果是100元，这时乙就会很困惑，不知道转账后该将帐户改为100还是0，如果按照正常操作乙会将账户A更新为0，正确执行，所以说一般不可重复读不一定会有问题。
• 幻读：银行会计甲对所有账户的金额单位更新为美元，这时银行会计乙又插入了两条金额单位为人民币的数据，银行会计甲更新完后查数据发现有几条还是人民币，于是以为自己产生了幻觉

以上就是事务并发时会产生的问题。

事务的隔离级别

针对以上的四个常见的并发事务的问题，数据库设置了四种隔离级别来应对：

• Read uncommitted (读未提交)：最低级别，最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
• Read committed (读已提交)：允许读取并发事务已经提交的数据，可以阻⽌脏读，但是幻读或不可重复读仍有可能发⽣
• Repeatable read (可重复读)：对同⼀字段的多次读取结果都是⼀致的，除⾮数据是被本身事务⾃⼰所修改，可以阻⽌脏读和不可重复读，但幻读仍有可能发⽣
• Serializable (串行化)： 最⾼的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执⾏，这样事务之间就完全不可能产⽣⼲扰，也就是说，该级别可以防⽌脏读、不可重复读以及幻读，对于同一行记录，写会加写锁，读会加读锁。当出现读写锁冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行

当然，随着隔离级别的增高，并发性能也会逐渐下降。

结合隔离问题和隔离机制举例说明，在这样一个事务流程下：

我们来看看在不同的隔离级别下，事务 A 会有哪些不同的返回结果，也就是图里面 V1、V2、V3 的返回值分别是什么。

• 若隔离级别是读未提交， 则 V1 的值就是 2。这时候事务 B 虽然还没有提交，但是结果已经被 A 看到了。因此，V2、V3 也都是 2。
• 若隔离级别是读提交，则 V1 是 1，V2 的值是 2。事务 B 的更新在提交后才能被 A 看到。所以， V3 的值也是 2。
• 若隔离级别是可重复读，则 V1、V2 是 1，V3 是 2。之所以 V2 还是 1，遵循的就是这个要求：事务在执行期间看到的数据前后必须是一致的。
• 若隔离级别是串行化，则在事务 B 执行“将 1 改成 2”的时候，会被锁住。直到事务 A 提交后，事务 B 才可以继续执行。所以从 A 的角度看， V1、V2 值是 1，V3 的值是 2。

在实现上，数据库里面会创建一个视图，访问的时候以视图的逻辑结果为准。

• 读未提交隔离级别下直接返回记录上的最新值，没有视图概念；
• 读提交隔离级别下，这个视图是在每个 SQL 语句开始执行的时候创建的，所以会在执行sql时发生变动（需要判断事务是否已提交，提交后才变动）
• 可重复读隔离级别下，这个视图是在事务启动时创建的，整个事务存在期间都用这个视图。假设你在管理一个个人银行账户表。一个表存了账户余额，一个表存了账单明细。到了月底你要做数据校对，也就是判断上个月的余额和当前余额的差额，是否与本月的账单明细一致。你一定希望在校对过程中，即使有用户发生了一笔新的交易，也不影响你的校对结果。这时候使用“可重复读”隔离级别就很方便。事务启动时的视图可以认为是静态的，不受其他事务更新的影响
• 串行化隔离级别下直接用加读写锁的方式来避免并行访问

我们可以看到在不同的隔离级别下，数据库行为是有所不同的。MySQL InnoDB 存储引擎的默认⽀持的隔离级别是 REPEATABLE-READ（可重读），与 SQL 标准不同的地⽅在于

• InnoDB 存储引擎在 REPEATABLE-READ（可重读） 事务隔离级别下使⽤的是Next-Key Lock 锁算法，因此可以避免幻读的产⽣，这与其他数据库系统(如SQL Server) 是不同的。
• InnoDB 存储引擎的默认⽀持的隔离级别是 REPEATABLE-READ（可重读） 已经可以完全保证事务的隔离性要求，即达到了 SQL标准的 SERIALIZABLE(可串⾏化) 隔离级别。
• 因为隔离级别越低，事务请求的锁越少，所以⼤部分数据库系统的隔离级别都是 READ-COMMITTED(读取提交内容) ，但是你要知道的是InnoDB 存储引擎默认使⽤REPEATABLE-READ（可重读）并不会有任何性能损失。

InnoDB 存储引擎在分布式事务 的情况下⼀般会⽤到 SERIALIZABLE(可串⾏化) 隔离级别

隔离机制的实现

理解了事务的隔离级别，我们再来看看事务隔离具体是怎么实现的。视图可以理解为数据副本，每次创建视图时，将当前『已持久化的数据』创建副本，后续直接从副本读取，从而达到数据隔离效果，存在视图的 2 种隔离级别：

1. 读提交，在每一条 SQL 开始执行时创建视图，隔离作用域仅限该条 SQL 语句。
2. 可重复读，事务启动时创建视图，因此，在事务任意时刻，对记录读取的值都是一样的。

其他 2 种无视图的隔离级别：

1. 读未提交，直接返回记录最新值。
2. 串行化，串行化通过读写锁来避免并行访问，读-读：允许并发执行，读-写：只能串行，写-写：只能串行

这里我们展开说明可重复读。在 MySQL 中，实际上每条记录在更新的时候都会同时记录一条回滚操作。记录上的最新值，通过回滚操作，都可以得到前一个状态的值。假设一个值从 1 被按顺序改成了 2、3、4，在回滚日志里面就会有类似下面的记录

当前值是 4，但是在查询这条记录的时候，不同时刻启动的事务会有不同的 read-view。如图中看到的，在视图 A、B、C 里面，这一个记录的值分别是 1、2、4，同一条记录在系统中可以存在多个版本，就是数据库的多版本并发控制（MVCC）。对于 read-view A，要得到 1，就必须将当前值依次执行图中所有的回滚操作得到。

回滚日志

回滚日志记录在undo log，undo log记录的是逆过程流，比如对表进行了一次insert，对应的就是delete；对字段a进行一次+1操作，那undo log就是一次-1操作

回滚日志总不能一直保留吧，什么时候删除呢？答案是，在不需要的时候才删除。也就是说，系统会判断，当没有事务再需要用到这些回滚日志时，回滚日志会被删除。什么时候才不需要了呢？就是当一个查询事务开启以后，在这个时刻之后，事务提交/回滚之前，所有更新产生的undo log都不能被删除

长事务的问题

长事务意味着系统里面会存在很老的事务视图。由于这些事务随时可能访问数据库里面的任何数据，所以这个事务提交之前，数据库里面它可能用到的回滚记录都必须保留，这就会导致大量占用存储空间。在 MySQL 5.5 及以前的版本，回滚日志是跟数据字典一起放在 ibdata 文件里的，即使长事务最终提交，回滚段被清理，文件也不会变小（逻辑清理）。最终只好为了清理回滚段，重建整个库（物理清理）。除了对回滚段的影响，长事务还占用锁资源，也可能拖垮整个库

事务的启动方式

事务启动方式有两种，一种是显式提交，另一种是通过设置禁止自动提交。

• 显式启动事务语句， begin 或 start transaction。配套的提交语句是 commit，回滚语句是 rollback。
• set autocommit=0，这个命令会将这个线程的自动提交关掉。意味着如果你只执行一个 select 语句，这个事务就启动了，而且并不会自动提交。这个事务持续存在直到你主动执行 commit 或 rollback 语句，或者断开连接。有些客户端连接框架会默认连接成功后先执行一个 set autocommit=0 的命令。这就导致接下来的查询都在事务中，如果是长连接，就导致了意外的长事务。因此，我会建议你总是使用 set autocommit=1, 通过显式语句的方式来启动事务。

有的开发同学会纠结“多一次交互”的问题。对于一个需要频繁使用事务的业务，第二种方式每个事务在开始时都不需要主动执行一次 “begin”，减少了语句的交互次数。建议使用 commit work and chain 语法。在 autocommit 为 1 的情况下，用 begin 显式启动的事务，如果执行 commit 则提交事务。如果执行 commit work and chain，则是提交事务并自动启动下一个事务，这样也省去了再次执行 begin 语句的开销。同时带来的好处是从程序开发的角度明确地知道每个语句是否处于事务中

MySQL的锁机制

数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构针对不同的分类尺度进行分类，根据加锁的范围，MySQL 里面的锁大致可以分成全局锁、表级锁和行锁三类，同时依据锁是否可以被共享又有读写锁的区别：

读写锁

表级锁和行级锁可以进一步划分为共享锁（s）和排他锁（X），在另一个维度上交叉组合：

• 共享锁（s），又被称为读锁，其他用户可以并发读取数据，但任何事务都不能获取数据上的排他锁，直到已释放所有共享锁。共享锁(S锁)又称为读锁，若事务T对数据对象A加上S锁，则事务T只能读A；其他事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。这就保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。本线程和其它线程都只能读
• 排他锁（X）：又称为写锁，若事务T对数据对象A加上X锁，则只允许T读取和修改A，其它任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。它防止任何其它事务获取资源上的锁，直到在事务的末尾将资源上的原始锁释放为止。在更新操作(INSERT、UPDATE 或 DELETE)过程中始终应用排它锁。本线程能读写，其它线程不能读写

两者之间的区别：

• 共享锁（S锁）：如果事务T对数据A加上共享锁后，则其他事务只能对A再加共享锁，不能加排他锁。获取共享锁的事务只能读数据，不能修改数据。
• 排他锁（X锁）：如果事务T对数据A加上排他锁后，则其他事务不能再对A加任任何类型的封锁。获取排他锁的事务既能读数据，又能修改数据。

当一个事务需要给自己需要的某个资源加锁的时候，如果遇到一个共享锁正锁定着自己需要的资源的时候，自己可以再加一个共享锁，不过不能加排他锁。但是，如果遇到自己需要锁定的资源已经被一个排他锁占有之后，则只能等待该锁定释放资源之后自己才能获取锁定资源并添加自己的锁定

全局锁/表级锁/行级锁

根据加锁的范围，MySQL 里面的锁大致可以分成全局锁、表级锁和行锁三类。

全局锁

顾名思义，全局锁就是对整个数据库实例加锁。MySQL 提供了一个加全局读锁的方法，命令是 Flush tables with read lock (FTWRL)。当你需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句。

全局锁的典型使用场景是，做全库逻辑备份。也就是把整库每个表都 select 出来存成文本。让整库都只读，听上去就很危险：

• 如果你在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆
• 如果你在从库上备份，那么备份期间从库不能执行主库同步过来的 binlog，会导致主从延迟。

看来加全局锁不太好。但是细想一下，备份为什么要加锁呢？我们来看一下不加锁会有什么问题

备份不加锁的问题

现在发起一个逻辑备份。假设备份期间，有一个用户，他购买了一门课程，业务逻辑里就要扣掉他的余额，然后往已购课程里面加上一门课。如果时间顺序上是先备份账户余额表 (u_account)，然后用户购买，然后备份用户课程表 (u_course)，会怎么样呢？你可以看一下这个图：

可以看到，这个备份结果里，用户 A 的数据状态是“账户余额没扣，但是用户课程表里面已经多了一门课”。如果后面用这个备份来恢复数据的话，用户 A 就发现，自己赚了，也就是说，不加锁的话，备份系统备份的得到的库不是一个逻辑时间点，这个视图是逻辑不一致的

一致性读

前面讲事务隔离的时候，有一个方法能够拿到一致性视图的，就是在可重复读隔离级别下开启一个事务，官方自带的逻辑备份工具是 mysqldump。当 mysqldump 使用参数–single-transaction 的时候，导数据之前就会启动一个事务，来确保拿到一致性视图。而由于 MVCC 的支持，这个过程中数据是可以正常更新的，一致性读是好，但前提是引擎要支持这个隔离级别，InnoDB支持而 MyISAM不支持

表级锁

MySQL 里面表级别的锁有两种：一种是表锁，一种是元数据锁（meta data lock，MDL)

表锁

表锁的语法是 lock tables … read/write。与 FTWRL 类似，可以用 unlock tables 主动释放锁，也可以在客户端断开的时候自动释放。需要注意，lock tables 语法除了会限制别的线程的读写外，也限定了本线程接下来的操作对象。

举个例子, 如果在某个线程 A 中执行 lock tables t1 read, t2 write; 这个语句，

• 其他线程写 t1、读写 t2 的语句都会被阻塞。
• 线程 A 在执行 unlock tables 之前，也只能执行读 t1、读写 t2 的操作。连写 t1 都不允许，自然也不能访问其他表。

加上读锁，不会限制别的线程读，但会限制别的线程写。加上写锁，会限制别的线程读写，在还没有出现更细粒度的锁的时候，表锁是最常用的处理并发的方式。而对于 InnoDB 这种支持行锁的引擎，一般不使用 lock tables 命令来控制并发，毕竟锁住整个表的影响面还是太大

MDL锁

MDL 不需要显式使用，在访问一个表的时候会被自动加上。MDL 的作用是，保证读写的正确性。你可以想象一下，如果一个查询正在遍历一个表中的数据，而执行期间另一个线程对这个表结构做变更，删了一列，那么查询线程拿到的结果跟表结构对不上，肯定是不行的。因此，在 MySQL 5.5 版本中引入了 MDL，当对一个表做增删改查操作的时候，加 MDL 读锁；当要对表做结构变更操作的时候，加 MDL 写锁

• 读锁之间不互斥，因此你可以有多个线程同时对一张表增删改查。
• 读写锁之间、写锁之间是互斥的，用来保证变更表结构操作的安全性。因此，如果有两个线程要同时给一个表加字段，其中一个要等另一个执行完才能开始执行

小表问题

给一个表加字段，或者修改字段，或者加索引，需要扫描全表的数据。这往往会导致不可预知的问题：

我们可以看到 session A 先启动，这时候会对表 t 加一个 MDL 读锁。

1. 由于 session B 需要的也是 MDL 读锁(因为读锁是共享锁)，因此可以正常执行。
2. 之后 session C 会被 blocked，是因为 session A 的 MDL 读锁还没有释放，而 session C 需要 MDL 写锁，因此只能被阻塞
3. 之后所有要在表 t 上新申请 MDL 读锁的请求也会被 session C 阻塞。mysql server 端对于sessionC,D有一个队列决定谁先执行

前面我们说了，所有对表的增删改查操作都需要先申请 MDL 读锁，就都被锁住，等于这个表现在完全不可读写了。如果某个表上的查询语句频繁，而且客户端有重试机制，也就是说超时后会再起一个新 session 再请求的话，这个库的线程很快就会爆满。

事务中的 MDL 锁，在语句执行开始时申请，但是语句结束后并不会马上释放，而会等到整个事务提交后再释放，梦幻联动到我们对长事务的探索，长事务坏处：1、导致undo log过多，占用存储空间 2、获取的锁要等到事务结束才释放，有可能会阻塞请求或者线程爆满

比较理想的机制是，在 alter table 语句里面设定等待时间，如果在这个指定的等待时间里面能够拿到 MDL 写锁最好，拿不到也不要阻塞后面的业务语句，先放弃。之后开发人员或者 DBA 再通过重试命令重复这个过程，其实就是我们在并发中学到的RetreenedLock等待可中断、超时放弃锁的机制，所以其实机制一通百通

其它表级锁【意向共享锁&意向排他锁】

意向锁的作用就是当一个事务在需要获取资源锁定的时候，如果遇到自己需要的资源已经被排他锁占用的时候，该事务可以需要锁定行的表上面添加一个合适的意向锁。

• 如果自己需要一个共享锁，那么就在表上面添加一个意向共享锁。
• 而如果自己需要的是某行（或者某些行）上面添加一个排他锁的话，则先在表上面添加一个意向排他锁。
• 这里的意向锁是表级锁，表示的是一种意向，仅仅表示事务正在读或写某一行记录，在真正加行锁时才会判断是否冲突。意向锁是InnoDB自动加的，不需要用户干预

意向共享锁可以同时并存多个，但是意向排他锁同时只能有一个存在

• 意向共享锁（IS）： 表示事务准备给数据行记入共享锁，事务在一个数据行加共享锁前必须先取得该表的IS锁
• 意向排他锁（IX）： 表示事务准备给数据行加入排他锁，事务在一个数据行加排他锁前必须先取得该表的IX锁。

当一个事务请求的锁模式与当前的锁兼容，InnoDB就将请求的锁授予该事务；反之如果请求不兼容，则该事物就等待锁释放

行级锁

MySQL 的行锁是在引擎层由各个引擎自己实现的。但并不是所有的引擎都支持行锁，比如 MyISAM 引擎就不支持行锁。不支持行锁意味着并发控制只能使用表锁，对于这种引擎的表，同一张表上任何时刻只能有一个更新在执行，这就会影响到业务并发度。InnoDB 是支持行锁的，这也是 MyISAM 被 InnoDB 替代的重要原因之一

顾名思义，行锁就是针对数据表中行记录的锁。这很好理解，比如事务 A 更新了一行，而这时候事务 B 也要更新同一行，则必须等事务 A 的操作完成后才能进行更新

两阶段锁

在下面的操作序列中，事务 B 的 update 语句执行时会是什么现象呢？假设字段 id 是表 t 的主键

这个问题的结论取决于事务 A 在执行完两条 update 语句后，持有哪些锁，以及在什么时候释放。可以验证一下：实际上事务 B 的 update 语句会被阻塞，直到事务 A 执行 commit 之后，事务 B 才能继续执行，其实事务 A 持有的两个记录的行锁，都是在 commit 的时候才释放的

在 InnoDB 事务中，行锁是在需要的时候才加上的，但并不是不需要了就立刻释放，而是要等到事务结束时才释放。这个就是两阶段锁协议，所以如果事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放，假设顾客A、C要在电影院B买票。

1. 从顾客 A 账户余额中扣除电影票价；
2. 给影院 B 的账户余额增加这张电影票价；
3. 记录一条交易日志。

也就是说，要完成这个交易，我们需要 update 两条记录，并 insert 一条记录。当然，为了保证交易的原子性，我们要把这三个操作放在一个事务中。

那么，你会怎样安排这三个语句在事务中的顺序呢？试想如果同时有另外一个顾客 C 要在影院 B 买票，那么这两个事务冲突的部分就是语句 2 了。因为它们要更新同一个影院账户的余额，需要修改同一行数据。根据两阶段锁协议，不论你怎样安排语句顺序，所有的操作需要的行锁都是在事务提交的时候才释放的。所以，如果把语句 2 安排在最后，比如按照 3、1、2 这样的顺序，那么影院账户余额这一行的锁时间就最少。这就最大程度地减少了事务之间的锁等待，提升了并发度。

死锁的检测与避免

当并发系统中不同线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都进入无限等待的状态，称为死锁，InnoDB的行级锁是基于索引实现的，如果查询语句未命中任何索引，那么InnoDB会使用表级锁. 此外，InnoDB的行级锁是针对索引加的锁，不针对数据记录，因此即使访问不同行的记录，如果使用了相同的索引键仍然会出现锁冲突

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

• 一种策略是，直接进入等待，直到超时。这个超时时间可以通过参数 innodb_lock_wait_timeout 来设置。
• 一种策略是，主动发起死锁检测，发现死锁后**，主动回滚死锁链条中的某一个事务，让其他事务得以继续执行**，其实就是破坏不可抢占条件。将参数 innodb_deadlock_detect 设置为 on，表示开启这个逻辑。

在 InnoDB 中，innodb_lock_wait_timeout 的默认值是 50s，意味着如果采用第一个策略，当出现死锁以后，第一个被锁住的线程要过 50s 才会超时退出，然后其他线程才有可能继续执行。对于在线服务来说，这个等待时间往往是无法接受的。但是，我们又不可能直接把这个时间设置成一个很小的值，比如 1s。这样当出现死锁的时候，确实很快就可以解开，但如果不是死锁，而是简单的锁等待呢？所以，超时时间设置太短的话，会出现很多误伤。所以，正常情况下我们还是要采用第二种策略，即主动死锁检测，而且 innodb_deadlock_detect 的默认值本身就是 on。主动死锁检测在发生死锁的时候，是能够快速发现并进行处理的，但是它也是有额外负担的

主动检测的问题

每个新来的被堵住的线程，都要判断会不会由于自己的加入导致了死锁，这是一个时间复杂度是 O(n) 的操作。假设有 1000 个并发线程要同时更新同一行，那么死锁检测操作就是 100 万这个量级的。虽然最终检测的结果是没有死锁，但是这期间要消耗大量的 CPU 资源。因此，你就会看到 CPU 利用率很高，但是每秒却执行不了几个事务

如何避免死锁

发生死锁后，InnoDB一般都可以检测到，并使一个事务释放锁回退，另一个则可以获取锁完成事务，我们可以采取以上方式避免死锁：

• 通过表级锁来减少死锁产生的概率；
• 多个程序尽量约定以相同的顺序访问表
• 同一个事务尽可能做到一次锁定所需要的所有资源

以上关于死锁

表级锁&行级锁总结

MyISAM和InnoDB存储引擎使⽤的锁：MyISAM采⽤表级锁(table-level locking)。InnoDB⽀持⾏级锁(row-level locking)和表级锁,默认为⾏级锁,表级锁和⾏级锁对⽐：

• 表级锁： MySQL中锁定粒度较大的⼀种锁，对当前操作的整张表加锁，实现简单，资源消耗也⽐较少，加锁快，不会出现死锁。其锁定粒度最⼤，触发锁冲突的概率最高，并发度最低，MyISAM和 InnoDB引擎都⽀持表级锁。
• ⾏级锁： MySQL中锁定 粒度最⼩的⼀种锁，只针对当前操作的⾏进⾏加锁。 ⾏级锁能⼤⼤减少数据库操作的冲突。其加锁粒度最⼩，并发度⾼，但加锁的开销也最⼤，加锁慢，会出现死锁。

InnoDB行级锁支持的算法有如下三种算法

• Record Lock: 对索引项加锁，锁定符合条件的行。其他事务不能修改和删除加锁项
• Gap Lock: 对索引项之间的“间隙”加锁，锁定记录的范围（对第一条记录前的间隙或最后一条将记录后的间隙加锁），不包含索引项本身。其他事务不能在锁范围内插入数据，这样就防止了别的事务新增幻影行。Gap锁设计的⽬的是为了阻⽌多个事务将记录插⼊到同⼀范围内，⽽这会导致幻读问题的产⽣；除了外键约束和唯⼀性检查外，其余情况关闭Gap，仅使⽤record
• Next-key Lock： 锁定索引项本身和索引范围。即Record Lock和Gap Lock的结合。Innodb对于⾏的查询使⽤next-key lock；当查询的索引含有唯⼀属性时，将next-key lock降级为record key

虽然使用行级索具有粒度小、并发度高等特点，但是表级锁有时候也是非常必要的：

• 事务更新大表中的大部分数据直接使用表级锁效率更高；
• 事务比较复杂**，使用行级索很可能引起死锁导致回滚**

Next-key Lock的设计其实就是为了解决幻读问题，这样，Innodb就可以在可重复读的隔离级别基础之上实现串行隔离级别

锁与事务的实现

上文我们花大量的篇幅介绍了事务的实现和锁的机制，这部分我们来把他们联系起来，即锁是如何在事务的实现中发挥作用，我们知道读未提交不需要做任何控制，所以不讨论，串行化是指对数据加了读写锁，而且由于事务提交后才会释放锁，且其它线程不能对数据再加任何锁，也即数据对其它线程不可见，实现机制比较明确，这里也不多做讨论。

提出问题

可重复读级别下，事务中读取的数据在整个事务过程中都是一致的，那么别的事务更新了数据，当前事务再去更新数据的时候，看到的是更新后的，还是更新前的？举个例子，初始插入值为insert into t(id, k) values(1,1),(2,2);

需要注意，begin/start transaction 命令并不是一个事务的起点，在执行到它们之后的第一个操作 InnoDB 表的语句，事务才真正启动。如果你想要马上启动一个事务，可以使用 start transaction with consistent snapshot 这个命令

1. 事务 C 没有显式地使用 begin/commit，表示这个 update 语句本身就是一个事务，语句完成的时候会自动提交，因为事务C本来就只有一条执行语句。
2. 事务 B 在更新了行之后查询
3. 事务 A 在一个只读事务中查询，并且时间顺序上是在事务 B 的查询之后，接着提交
4. 事务 B 提交

在这里，事务 B 查到的 k 的值是 3，而事务 A 查到的 k 的值是 1，我们需要知道为什么结果是这样

MVCC机制

这部分详细讲解下MVCC机制，包括快照和事务ID

快照

在 MySQL 里，有两个视图的概念，这两个视图分别用于不同的场景。

• 一个是 view。它是一个用查询语句定义的虚拟表，在调用的时候执行查询语句并生成结果。创建视图的语法是 create view … ，而它的查询方法与表一样。
• 一个是 InnoDB 在实现 MVCC 时用到的一致性读视图，即 consistent read view，用于支持 RC（Read Committed，读提交）和 RR（Repeatable Read，可重复读）隔离级别的实现。它没有物理结构，作用是事务执行期间用来定义“我能看到什么数据”

第二种视图更像是一种快照。在可重复读隔离级别下，事务在启动的时候就“拍了个快照”。注意，这个快照是基于整库的。

事务ID

InnoDB 里面每个事务有一个唯一的事务 ID，叫作 transaction id。它是在事务开始的时候向 InnoDB 的事务系统申请的，是按申请顺序严格递增的。而每行数据也都是有多个版本的。每次事务更新数据的时候，都会生成一个新的数据版本，并且把 transaction id 赋值给这个数据版本的事务 ID，记为 row trx_id。同时，旧的数据版本要保留，并且在新的数据版本中，能够有信息可以直接拿到它。也就是说，数据表中的一行记录，其实可能有多个版本 (row)，每个版本有自己的 row trx_id

比如，如果有一个事务，它的低水位事务ID是 18，那么当它访问这一行数据时，就会从 V4 通过 U3 计算出 V3，所以在它看来，这一行的值是 11

undo log

undo log 在哪呢？实际上，上图的三个虚线箭头，就是 undo log；而 V1、V2、V3 并不是物理上真实存在的，而是每次需要的时候根据当前版本和 undo log 计算出来的。比如，需要 V2 的时候，就是通过 V4 依次执行 U3、U2 算出来，返回过来看

回滚段是真实存在的，而视图也就是快照是一种逻辑形态，是计算出来的。

MVCC实现

按照可重复读的定义，一个事务启动的时候，能够看到所有已经提交的事务结果。但是之后，这个事务执行期间，其他事务的更新对它不可见。因此，一个事务只需要在启动的时候声明说，

• “以我启动的时刻为准，如果一个数据版本是在我启动之前生成的，就认；
• 如果是我启动以后才生成的，我就不认，我必须要找到它的上一个版本”。

当然，如果“上一个版本”也不可见，那就得继续往前找。还有，如果是这个事务自己更新的数据，它自己还是要认的

在实现上， InnoDB 为每个事务构造了一个数组，用来保存这个事务启动瞬间，当前正在“活跃”的所有事务 ID。“活跃”指的就是，启动了但还没提交。数组里面事务 ID 的最小值记为低水位，当前系统里面已经创建过的事务 ID 的最大值加 1 记为高水位。这个视图数组和高水位，就组成了当前事务的一致性视图（read-view）

这样，对于当前事务的启动瞬间来说，一个数据版本的 row trx_id（对一个数据的操作ID），有以下几种可能：

1. 如果落在绿色部分，表示这个版本是已提交的事务或者是当前事务自己生成的，这个数据是可见的；
2. 如果落在黄色部分，那就包括两种情况
   • a. 若 row trx_id 在活跃数组中，表示这个版本是由还没提交的事务生成的，不可见；
   • b. 若 row trx_id 不在活跃数组中，表示这个版本是已经提交了的事务生成的，可见。
3. 如果落在红色部分，表示这个版本是由将来启动的事务生成的，是肯定不可见的；事务ID一定大于当前。

我们举个例子，假如事务ID从【90,100】，其中90,91,93,95,98,99,100已提交，则活跃事务ID数组为【92,96,97】，低水位为92，当前事务为94，高水位为101。则可以进行如下划分：

• 绿色区域，低水位之前已提交的事务ID，90,91可见。包括当前事务虽然未提交刚开启，但是自身可见，94可见
• 黄色区域，低水位到高水位之间，剩下的【92,100】，这一系列事务ID，分为两类
  • a. 若 row trx_id 在活跃数组中，【92,96,97】不可见。
  • b. 若 row trx_id 不在活跃数组中，93,95,98,99,100均可见
• 红色区域，未开始的事务101及以后的事务ID都不可见

以上就是一致性视图的使用规范。对于上边的行数据版本链问题，低水位是18，则在所有版本的数据中，trx_id低于18的版本都可见，所以值为11肯定是可见的，有了这个声明后，系统里面随后发生的更新，是不是就跟这个事务看到的内容无关了呢？因为之后的更新，生成的版本一定属于上面的 3或者 2(a) 的情况，而对它来说，这些新的数据版本是不存在的，所以这个事务的快照，就是“静态”的了

解决问题

接下来，我们继续看一下开始提出问题的三个事务，分析下事务 A 的语句返回的结果，为什么是 k=1。这里，我们不妨做如下假设：

• 事务 A 开始前，系统里面只有一个活跃事务 ID 是 99；
• 事务 A、B、C 的版本号分别是 100、101、102，且当前系统里只有这四个事务；

三个事务开始前，(1,1）这一行数据的 row trx_id 是 90。这样，事务 A 的视图数组就是**[99,100], 事务 B 的视图数组是[99,100,101], 事务 C 的视图数组是[99,100,101,102]**。为了简化分析，我先把其他干扰语句去掉，只画出跟事务 A 查询逻辑有关的操作：

• 从图中可以看到，第一个有效更新是事务 C，把数据从 (1,1) 改成了 (1,2)。这时候，这个数据的最新版本的 row trx_id 是 102，而 90 这个版本已经成为了历史版本
• 第二个有效更新是事务 B，把数据从 (1,2) 改成了 (1,3)。这时候，这个数据的最新版本（即 row trx_id）是 101，而 102 又成为了历史版本

在事务 A 查询的时候，其实事务 B 还没有提交，但是它生成的 (1,3) 这个版本已经变成当前版本了。但这个版本对事务 A 必须是不可见的，否则就变成脏读了

读取逻辑

好，现在事务 A 要来读数据了，它的视图数组是[99,100]。当然了，读数据都是从当前版本读起的。所以，事务 A 查询语句的读数据流程是这样的：

1. 找到 (1,3) 的时候，判断出 row trx_id=101，比高水位大，处于红色区域，不可见；
2. 接着，找到上一个历史版本，一看 row trx_id=102，比高水位大，处于红色区域，不可见；
3. 再往前找，终于找到了（1,1)，它的 row trx_id=90，比低水位小，处于绿色区域，可见。

这样执行下来，虽然期间这一行数据被修改过，但是事务 A 不论在什么时候查询，看到这行数据的结果都是一致的，所以我们称之为一致性读，一个数据版本，对于一个事务视图来说，除了自己的更新总是可见以外，有三种情况：

• 版本未提交，不可见；
• 版本已提交，但是是在视图创建后提交的，不可见；
• 版本已提交，而且是在视图创建前提交的，可见。

现在，我们用这个规则来判断查询结果

1. 事务 A 的查询语句的视图数组是在事务 A 启动的时候生成的，这时候：(1,3) 还没提交，属于情况 1，不可见；
2. (1,2) 虽然提交了，但是是在视图数组创建之后提交的，属于情况 2，不可见
3. (1,1) 是在视图数组创建之前提交的，可见。

去掉数字对比后，只用时间先后顺序来判断，分析起来是不是轻松多了。所以，后面我们就都用这个规则来分析

更新逻辑

事务 B 的 update 语句，如果按照一致性读，好像结果不对？事务 B 的视图数组是先生成的，之后事务 C 才提交，不是应该看不见 (1,2) 吗，怎么能算出 (1,3) 来

是的，如果事务 B 在更新之前查询一次数据，这个查询返回的 k 的值确实是 1

但是，当它要去更新数据的时候，就不能再在历史版本上更新了，否则事务 C 的更新就丢失了。因此，事务 B 此时的 set k=k+1 是在（1,2）的基础上进行的操作。所以，这里就用到了这样一条规则：更新数据都是先读后写的，而这个读，只能读当前的值，称为当前读（current read）

因此，在更新的时候，当前读拿到的数据是 (1,2)，更新后生成了新版本的数据 (1,3)，这个新版本的 row trx_id 是 101。所以，在执行事务 B 查询语句的时候，一看自己的版本号是 101，最新数据的版本号也是 101，是自己的更新，可以直接使用，所以查询得到的 k 的值是 3。有点像Java的volatile机制。

当前读

这里我们提到了一个概念，叫作当前读。其实，除了 update 语句外，select 语句如果加锁，也是当前读。所以，如果把事务 A 的查询语句 select * from t where id=1 修改一下，加上 lock in share mode 或 for update，也都可以读到版本号是 101 的数据，返回的 k 的值是 3。下面这两个 select 语句，就是分别加了读锁（S 锁，共享锁）和写锁（X 锁，排他锁）

mysql> select k from t where id=1 lock in share mode;
mysql> select k from t where id=1 for update;
1
2
3

言归正传，假设事务 C 不是马上提交的，而是变成了下面的事务 C’，会怎么样呢？

事务 C’的不同是，更新后并没有马上提交，在它提交前，事务 B 的更新语句先发起了。前面说过了，虽然事务 C’还没提交，但是 (1,2) 这个版本也已经生成了，并且是当前的最新版本。那么，事务 B 的更新语句会怎么处理呢？

事务 C’没提交，也就是说 (1,2) 这个版本上的写锁还没释放。而事务 B更新时 是当前读，必须要读最新版本，而且必须加锁，因此就被锁住了，必须等到事务 C’释放这个锁，才能继续它的当前读

可重复读和读提交的实现

到这里，我们把一致性读、当前读和行锁就串起来了。那么事务的可重复读的能力是怎么实现的？

• 可重复读的核心就是一致性读（consistent read）；事务更新数据的时候，只能用当前读。如果当前的记录的行锁被其他事务占用的话，就需要进入锁等待。
• 读提交的逻辑和可重复读的逻辑类似，它们最主要的区别是：在可重复读隔离级别下，只需要在事务开始的时候创建一致性视图，之后事务里的其他查询都共用这个一致性视图；在读提交隔离级别下，每一个语句执行前都会重新算出一个新的视图。

那么，我们再看一下，在读提交隔离级别下，事务 A 和事务 B 的查询语句查到的 k，分别应该是多少呢？这里需要说明一下，“start transaction with consistent snapshot; ”的意思是从这个语句开始，创建一个持续整个事务的一致性快照。所以，在读提交隔离级别下，这个用法就没意义了，等效于普通的 start transaction。下面是读提交时的状态图，可以看到这两个查询语句的创建视图数组的时机发生了变化，就是图中的 read view 框。（注意：这里，我们用的还是事务 C 的逻辑直接提交，而不是事务 C’）

这时，事务 A 的查询语句的视图数组是在执行这个语句的时候创建的，时序上 (1,2)、(1,3) 的生成时间都在创建这个视图数组的时刻之前。但是，在这个时刻：

• (1,3) 事务B还没提交，属于情况 1，不可见；
• (1,2) 事务C提交了，属于情况 3，可见。

所以，这时候事务 A 查询语句返回的是 k=2。显然地，事务 B 查询结果 k=3，因为B的视图里，C已经提交了。自己状态又可见，直接加2次。

隔离级别与行锁

Innodb对于行级锁，行文至此，我们最终探讨一次四种隔离级别是如何产生效果的呢？是依据MVCC机制和行级别的锁来实现的，针对每种隔离级别分别介绍一下：

• 读未提交，不创建视图，所有语句不加任何锁，有脏读问题。解决办法就是下面的读已提交
• 读已提交，执行sql时创建一致性视图，SELECT语句是一致性读，一致性读会根据 row trx_id 和一致性视图确定数据版本的可见性，且SELECT不加锁，更新语句使用当前读机制+两阶段行锁（Record Lock排它锁）机制，UPDATE加排他锁，存在的问题不可重复读。即在一次事务之间，进行了两次读取，但是结果不一样，不可重复读问题
• 可重复读，事务开始时创建一致性视图，查询语句是一致性读，一致性读会根据 row trx_id 和一致性视图确定数据版本的可见性，且SELECT不加锁，更新语句使用当前读机制+两阶段行锁（Record Lock排它锁）机制，UPDATE加排他锁，可重复读阻止的写事务包括update（只给存在的数据行加上了锁），但是不包括insert、delete（新行不存在，所以没有办法加锁）
• 串行化，不创建视图，读加读锁，写加跨行级别Next-key Lock排他锁。阻止其它读写事务 ，基本上就是一个个执行事务，所以叫串行化。

整体的隔离机制介绍如上，可算是对事务和锁的实现有了一个全盘的掌握了。