【MySQL实战45讲基础篇】(task3)事务隔离

学习总结

（1）学习了MySQL的事务隔离级别的现象和实现，根据实现原理分析了长事务存在的风险，以及如何用正确的方式避免长事务。

（2）重申幻读定义：事务a 开启，查询符合条件的数据，发现有10条，准备将这10条记录修改，此时事务b开启，插入了一条符合事务a查询条件的记录。提交事务，回到事务a， a也提交事务，当再次查询到时候，发现修改了11条…感觉发生了幻觉一样，此为幻读。

事务隔离级别	脏读	不可重复读	幻读
读未提交	（read-uncommitted）	是	是
不可重复读（read-committed）	否	是	是
可重复读（repeatable-read）	否	否	是
串行化（serializable）	否	否	否

文章目录

• ​​学习总结​​
• ​​一、隔离性与隔离级别​​

• ​​1.1 不同事务隔离级别的区别​​
• ​​1.2 “读提交”和“可重复读”​​
• ​​1.3 隔离级别的配置方法​​
• ​​1.4 可重复读的场景​​

• ​​二、事务隔离的实现​​

• ​​2.1 事务隔离的实现​​
• ​​2.2 三个为什么​​

• ​​（1）回滚日志什么时候删除？​​
• ​​（2）什么时候不需要了？​​
• ​​（3）为什么尽量不要使用长事务​​

• ​​三、事务的启动方式​​

• ​​3.1 启动方式​​
• ​​3.2 建议使用法一​​
• ​​3.3 如何查询事务​​

• ​​四、作业​​
• ​​五、课后复习（常见面试题）​​

• ​​1.事务的概念是什么?​​
• ​​2.mysql的事务隔离级别读未提交, 读已提交, 可重复读, 串行各是什么意思?​​
• ​​3.读已提交, 可重复读是怎么通过视图构建实现的?​​
• ​​4.可重复读的使用场景举例?​​
• ​​5.事务隔离是怎么通过read-view(读视图)实现的?​​
• ​​6.并发版本控制(MCVV)的概念是什么, 是怎么实现的?​​
• ​​7.使用长事务的弊病? 为什么使用常事务可能拖垮整个库?​​
• ​​8.事务的启动方式有哪几种?​​
• ​​9.commit work and chain的语法是做什么用的?​​
• ​​10.怎么查询各个表中的长事务?​​
• ​​11.如何避免长事务的出现?​​

• ​​Reference​​

事务就是要保证一组数据库操作，要么全部成功，要么全部失败。

在 MySQL 中，事务支持是在引擎层实现的。你现在知道，MySQL 是一个支持多引擎的系统，但并不是所有的引擎都支持事务。比如 MySQL 原生的 MyISAM 引擎就不支持事务，这也是 MyISAM 被 InnoDB 取代的重要原因之一。

一、隔离性与隔离级别

ACID（Atomicity、Consistency、Isolation、Durability，即原子性、一致性、隔离性、持久性）。当数据库上有多个事务同时执行的时候，就可能出现脏读（dirty read）、不可重复读（non-repeatable read）、幻读（phantom read）的问题，为了解决这些问题，就有了“隔离级别”的概念。

1.1 不同事务隔离级别的区别

隔离得越严实，效率就会越低。所以很多时候，我们都要在二者之间寻找一个平衡点。SQL 标准的事务隔离级别包括：读未提交（read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（serializable ）：

• 读未提交是指，一个事务还没提交时，它做的变更就能被别的事务看到。
• 读提交是指，一个事务提交之后，它做的变更才会被其他事务看到。
• 可重复读是指，一个事务执行过程中看到的数据，总是跟这个事务在启动时看到的数据是一致的。当然在可重复读隔离级别下，未提交变更对其他事务也是不可见的。
• 串行化，顾名思义是对于同一行记录，“写”会加“写锁”，“读”会加“读锁”。当出现读写锁冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行。

1.2 “读提交”和“可重复读”

其中“读提交”和“可重复读”比较难理解，下面用一个例子说明这几种隔离级别。假设数据表 T 中只有一列，其中一行的值为 1，下面是按照时间顺序执行两个事务的行为。

mysql> create table T(c int) engine=InnoDB;
insert into T(c) values(1);      

看看在不同的隔离级别下，事务 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 语句开始执行的时候创建的。

“读未提交”隔离级别下直接返回记录上的最新值，没有视图概念；

而“串行化”隔离级别下直接用加锁的方式来避免并行访问。

1.3 隔离级别的配置方法

可以看到在不同的隔离级别下，数据库行为是有所不同的。Oracle 数据库的默认隔离级别其实就是“读提交”，因此对于一些从 Oracle 迁移到 MySQL 的应用，为保证数据库隔离级别的一致，你一定要记得将 MySQL 的隔离级别设置为“读提交”。

配置的方式是，将启动参数 ​

​transaction-isolation​

​​ 的值设置成 ​

​READ-COMMITTED​

​​。可以用 ​

​show variables​

​ 来查看当前的值。

mysql> show variables like 'transaction_isolation';

+-----------------------+----------------+

| Variable_name | Value |

+-----------------------+----------------+

| transaction_isolation | READ-COMMITTED |

+-----------------------+----------------+      

每种隔离级别都有自己的使用场景，要根据自己的业务情况来定。

1.4 可重复读的场景

【数据校对逻辑的案例】

假设你在管理一个个人银行账户表。一个表存了账户余额，一个表存了账单明细。到了月底你要做数据校对，也就是判断上个月的余额和当前余额的差额，是否与本月的账单明细一致。你一定希望在校对过程中，即使有用户发生了一笔新的交易，也不影响你的校对结果。

这时候使用“可重复读”隔离级别就很方便。事务启动时的视图可以认为是静态的，不受其他事务更新的影响。

二、事务隔离的实现

理解了事务的隔离级别，我们再来看看事务隔离具体是怎么实现的。这里展开说明“可重复读”。

在 MySQL 中，实际上每条记录在更新的时候都会同时记录一条回滚操作。记录上的最新值，通过回滚操作，都可以得到前一个状态的值。

2.1 事务隔离的实现

假设一个值从 1 被按顺序改成了 2、3、4，在回滚日志里面就会有类似下面的记录。

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

同时你会发现，即使现在有另外一个事务正在将 4 改成 5，这个事务跟 read-view A、B、C 对应的事务是不会冲突的。

2.2 三个为什么

（1）回滚日志什么时候删除？

在不需要的时候才删除。也就是说，系统会判断，当没有事务再需要用到这些回滚日志时，回滚日志会被删除。

（2）什么时候不需要了？

当系统里没有比这个回滚日志更早的 read-view 的时候。

（3）为什么尽量不要使用长事务

长事务意味着系统里面会存在很老的事务视图。由于这些事务随时可能访问数据库里面的任何数据，所以这个事务提交之前，数据库里面它可能用到的回滚记录都必须保留，这就会导致大量占用存储空间。

在 MySQL 5.5 及以前的版本，回滚日志是跟数据字典一起放在 ibdata 文件里的，即使长事务最终提交，回滚段被清理，文件也不会变小。ex：有一次数据只有 20GB，而回滚段有 200GB 的库。最终只好为了清理回滚段，重建整个库。

除了对回滚段的影响，长事务还占用锁资源，也可能拖垮整个库。

三、事务的启动方式

3.1 启动方式

• 显式启动事务语句， begin 或 start transaction。配套的提交语句是 commit，回滚语句是 rollback。
• ​

  ​set autocommit=0​

  ​，这个命令会将这个线程的自动提交关掉。意味着如果你只执行一个 select 语句，这个事务就启动了，而且并不会自动提交。这个事务持续存在直到你主动执行 commit 或 rollback 语句，或者断开连接。

3.2 建议使用法一

有些客户端连接框架会默认连接成功后先执行一个 set autocommit=0 的命令。这就导致接下来的查询都在事务中，如果是长连接，就导致了意外的长事务。因此，建议总是使用 set autocommit=1, 通过显式语句的方式来启动事务。

但是有的开发同学会纠结“多一次交互”的问题。对于一个需要频繁使用事务的业务，

第二种方式每个事务在开始时都不需要主动执行一次 “begin”，减少了语句的交互次数。如果有这个顾虑，建议使用 commit work and chain 语法。

在 autocommit 为 1 的情况下，用 begin 显式启动的事务，如果执行 commit 则提交事务。如果执行 commit work and chain，则是提交事务并自动启动下一个事务，这样也省去了再次执行 begin 语句的开销。同时带来的好处是从程序开发的角度明确地知道每个语句是否处于事务中。

3.3 如何查询事务

可以在 information_schema 库的 innodb_trx 这个表中查询长事务，比如下面这个语句，用于查找持续时间超过 60s 的事务。

select * from information_schema.innodb_trx where TIME_TO_SEC(timediff(now(),trx_started))>60      

四、作业

知道了系统里面应该避免长事务，如果你是业务开发负责人同时也是数据库负责人，你会有什么方案来避免出现或者处理这种情况呢？

【答】首先，从应用开发端来看：

• 确认是否使用了​

  ​set autocommit=0​

  ​​。这个确认工作可以在测试环境中开展，把 MySQL 的​

  ​general_log​

  ​​ 开起来，然后随便跑一个业务逻辑，通过​

  ​general_log​

  ​ 的日志来确认。一般框架如果会设置这个值，也就会提供参数来控制行为，你的目标就是把它改成 1。
• 确认是否有不必要的只读事务。有些框架会习惯不管什么语句先用 begin/commit 框起来。我见过有些是业务并没有这个需要，但是也把好几个​

  ​select​

  ​ 语句放到了事务中。这种只读事务可以去掉。
• 业务连接数据库的时候，根据业务本身的预估，通过​

  ​SET MAX_EXECUTION_TIME​

  ​ 命令，来控制每个语句执行的最长时间，避免单个语句意外执行太长时间。（为什么会意外？在后续的文章中会提到这类案例）

其次，从数据库端来看：

• 监控​

  ​information_schema.Innodb_trx​

  ​ 表，设置长事务阈值，超过就报警 / 或者 kill；
• Percona 的 pt-kill 这个工具不错，推荐使用；
• 在业务功能测试阶段要求输出所有的​

  ​general_log​

  ​，分析日志行为提前发现问题；
• 如果使用的是 MySQL 5.6 或者更新版本，把​

  ​innodb_undo_tablespaces​

  ​ 设置成 2（或更大的值）。如果真的出现大事务导致回滚段过大，这样设置后清理起来更方便。

五、课后复习（常见面试题）

1.事务的概念是什么?

事务是对数据库中数据操作的保证数据逻辑一致的最小操作单位。

2.mysql的事务隔离级别读未提交, 读已提交, 可重复读, 串行各是什么意思?

读未提交：一个事务读取到了其他事务未提交的操作。

读已提交：一个事务读取到了其他事务已经提交的操作。

可重复读：一个事务从它开始到结束整个生命周期中，所能读取到的数据内容和它启动的时候所能读到的数据内容是相同的。不会出现在事务运行的整个过程中，不同的时间点读取到的数据不一样的情况。

串行化：所有的事务都进行排队执行，事务之间不存才并发的情况。读有读锁，写有写锁。读、读之间不影响，读、写和写、写之间互相排斥，当遇到排斥的情况后，后发生的事务需要等待先发生的事务执行完成后才可以执行。

3.读已提交, 可重复读是怎么通过视图构建实现的?

读已提交：会在事务中的每一个SQL语句执行的时候都为对应的SQL创建一个一致性视图。此时这个SQL能读取到已经提交的事务对数据的操作。

可重复读：会在事务启动的时候，为整个事务创建一个一致性视图，这个视图会贯穿到这个事务执行结束。在整个事务执行过程中，都使用这个视图中的数据作为一致性读的依据。

4.可重复读的使用场景举例?

对账的时候应该很有用

库管盘货

5.事务隔离是怎么通过read-view(读视图)实现的?

每一行数有多个版本，当我们要去读取数据的时候，要判断这个数据的版本号，对当前事务而言，是否可见，如果不可见，则要根据undolog计算得到上一个版本。如果上一个版本也不符合要求，则要找到再上一个版本，

直到找到对应正确的数据版本。

6.并发版本控制(MCVV)的概念是什么, 是怎么实现的?

待补充。

​​​ https://database.51cto.com/art/202101/641019.htm​​

7.使用长事务的弊病? 为什么使用常事务可能拖垮整个库?

长事务导致表空间持续增长，即便是事务提交或者回滚后，回滚表空间被是否后，表空间大小仍然不会被缩小。

长事务的存在导致锁发生冲突或等待的几率大大增加。

如果某个应用有发生锁等待后尝试重新建立连接的机制，那么在发生锁等待或冲突的时候，应用就会不断地发起新的连接，导致MySQL的连接数被占用爆满。MySQL不能在提供连接服务，就挂掉了。

8.事务的启动方式有哪几种?

begin;–一致性读的视图不会马上创建，而是在执行begin后面的第一个操作innodb表的SQL语句时生成。这个SQL可以是select,update,delete,insert。事务ID也是此时被分配的

start transaction;–和begin的功能效果一样。

start transaciton with consistent snapshot;–该语句执行后，会马上创建一致性读的视图。这个是它和begin的区别。事务ID也是此时被分配的。

9.commit work and chain的语法是做什么用的?

提交上一个事务，并且再开启一个新的事务。它的功能等效于：commit + begin。

10.怎么查询各个表中的长事务?

​

​select * from information_schema.innodb_trx​

​​;

这个表中记录了所有正在运行的事务信息，里面有事务的开始时间。可以从这里看出哪些事务运行的时间比较长。

11.如何避免长事务的出现?

Reference