MySQL事务详细讲解

什么是事务:

事务（Transaction）是指数据库中执行的一系列操作被视为一个逻辑单元，要么全部成功执行，要么全部失败回滚，保证数据的一致性和完整性。
举个简单的例子，假设有一个银行账户转账的场景：
假设有两个账户，账户 A 的余额为 1000 元，账户 B 的余额为 500 元。现在要将账户 A 中的 200 元转到账户 B 中。
使用事务来执行这个转账过程可以保证数据的一致性，即要么转账成功并更新两个账户的余额，要么转账失败并不对账户余额做任何修改

1.事务有哪些特性

• 事务是由 MySQL 的引擎来实现的，我们常见的 InnoDB 引擎它是支持事务的。
• 并不是所有的引擎都能支持事务，比如 MySQL 原生的 MyISAM 引擎就不支持事务，所以大多数 MySQL 的引擎都是用 InnoDB。

1. 原子性（Atomicity）：事务是一个原子操作单元，要么全部执行成功，要么全部失败回滚。如果事务中的任何一部分操作失败，那么整个事务都会被回滚到初始状态，不会对数据库产生任何影响。
   例如：考虑一个银行转账的场景。假设一个事务包含两个操作：从账户 A 中转出 500 元，同时将同样的金额转入账户 B。如果转出操作成功但是转入操作失败，那么整个事务会被回滚，账户 A 的余额不会减少，账户 B 的余额也不会增加。

2. 一致性（Consistency）：事务在执行前和执行后，数据库中的数据必须保持一致性。这意味着事务在完成时，所有的约束条件、触发器等都得到满足，数据不会处于不一致的状态。
   例如：假设有两个表格：订单表和库存表。一个事务要求先插入一条订单记录，然后更新库存数量。如果库存数量不足以满足订单要求，事务将回滚并保持数据一致性，即不会产生订单记录而库存数量仍然减少。

3. 隔离性（Isolation）：事务的执行应该与其他事务相互隔离，保证每个事务在逻辑上都是独立的。一个事务的执行不应该受到其他事务的干扰。
   例如：考虑两个并发的事务 A 和 B。事务 A 向账户中存入 200 元，事务 B 同时查询账户余额。如果隔离级别设置得不够高，那么事务 B 可能会在事务 A 执行之前查询到错误的余额，因为事务 A 的修改可能在事务 B 查询之前不可见。这就是隔离性的概念。

4. 持久性（Durability）：一旦事务提交，其所做的修改将永久保存在数据库中，即使发生系统故障或电源故障，也不会丢失。
   例如：当一个事务成功提交后，数据库系统会确保相关的数据更新持久化到磁盘上，即使在提交后发生了系统崩溃，数据库可以通过使用日志文件来进行恢复，从而保证数据的持久性。

这些 ACID 特性保证了事务的可靠性和数据的一致性。通过正确使用事务，可以确保复杂的数据库操作在各种故障和异常情况下仍然能够保持数据的完整性和正确性。

InnoDB是如何保证事务的:

• 持久性是通过 redo log （重做日志）来保证的；
• 原子性是通过 undo log（回滚日志） 来保证的；
• 隔离性是通过 MVCC（多版本并发控制） 或锁机制来保证的；
• 一致性则是通过持久性+原子性+隔离性来保证；

2.并发事务会引起什么问题

• MySQL是允许多个客户端连接的,因此就会出现脏读（dirty read）、不可重复读（non-repeatable read）、幻读（phantom read） 的问题并发的问题

• 脏读（Dirty Read）：脏读是指一个事务读取了另一个事务尚未提交的数据。如果一个事务修改了某个数据项但还未提交，而另一个并行执行的事务读取了这个未提交的数据，那么就会导致脏读问题。
  例如:假设有两个事务 A 和 B，事务 A 修改了某个数据项的值但尚未提交，而事务 B 并行执行并读取了该数据项。如果事务 A 最终回滚了，那么事务 B 就读取了一个不存在或无效的数据，这就是脏读

• 不可重复读（Non-Repeatable Read）：不可重复读是指在一个事务中，多次读取同一数据项的结果不一致。这是由于并行事务可能在读取数据的过程中，其他事务对该数据进行了修改和提交。
  例如:考虑两个事务 A 和 B，事务 A 开始时读取了某个数据项的值，然后事务 B 并行执行并修改了该数据项的值，并提交了修改。接着，事务 A 再次读取同一数据项的值，发现与之前不一致，这就是不可重复读。

• 幻读（Phantom Read）：幻读是指在一个事务中，重复执行一个查询语句时，返回不同的结果集。这是由于并行事务在查询期间插入或删除了满足查询条件的新数据。
  例如: 假设事务 A 执行一个范围查询语句，例如 “SELECT * FROM 表名 WHERE 列名 BETWEEN 值1 AND 值2”，并返回结果集。在此期间，事务 B 并行地插入了一些新记录，这些新插入的记录恰好满足了事务 A 的查询条件，导致事务 A 再次执行相同的查询时，返回了不同的结果集。这就是幻读。

3.事务的隔离级别有哪些

当多个事务并发执行时可能会遇到「脏读、不可重复读、幻读」的现象，这些现象会对事务的一致性产生不同程序的影响,SQL 标准提出了四种隔离级别来规避这些现象，隔离级别越高，性能效率就越低，这四个隔离级别如下：

1. 读未提交（read uncommitted），指一个事务还没提交时，它做的变更就能被其他事务看到；
2. 读提交（read committed），指一个事务提交之后，它做的变更才能被其他事务看到；
3. 可重复读（repeatable read），指一个事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，MySQL InnoDB 引擎的默认隔离级别；
4. 串行化（serializable ）；会对记录加上读写锁，在多个事务对这条记录进行读写操作时，如果发生了读写冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行；
   
   注意:事务隔离级别越高，数据越安全，但是性能越低

• MySQL InnoDB 引擎的默认隔离级别虽然是「可重复读」，但是它很大程度上避免幻读现象,解决的方案有两种：

  • 针对快照读（普通 select 语句），是通过 MVCC 方式解决了幻读，因为可重复读隔离级别下，事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，即使中途有其他事务插入了一条数据，是查询不出来这条数据的，所以就很好了避免幻读问题。
  • 针对快照读（普通 select 语句），是通过 MVCC 方式解决了幻读，因为可重复读隔离级别下，事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，即使中途有其他事务插入了一条数据，是查询不出来这条数据的，所以就很好了避免幻读问题。

• 对于「读未提交」隔离级别的事务来说，因为可以读到未提交事务修改的数据，所以直接读取最新的数据就好了；

• 对于「串行化」隔离级别的事务来说，通过加读写锁的方式来避免并行访问；

• 对于「读提交」和「可重复读」隔离级别的事务来说，是通过 Read View 来实现的，它们的区别在于创建 Read View 的时机不同，可以把 Read View 理解成一个数据快照，就像相机拍照那样，定格某一时刻的风景。「读提交」隔离级别是在「每个语句执行前」都会重新生成一个 Read View，而「可重复读」隔离级别是「启动事务时」生成一个 Read View，然后整个事务期间都在用这个 Read View。

• 执行「开始事务」命令，并不意味着启动了事务: 执行了 begin/start transaction 命令后，并不代表事务启动了。只有在执行这个命令后，执行了增删查改操作的 SQL 语句，才是事务真正启动的时机；另外执行了 start transaction with consistent snapshot 命令，就会马上启动事务。

4.Read View在MVCC中如何工作

Read View 有四个重要的字段

• m_ids ：指的是在创建 Read View 时，当前数据库中「活跃事务」的事务 id 列表，注意是一个列表，“活跃事务”指的就是，启动了但还没提交的事务。
• min_trx_id ：指的是在创建 Read View 时，当前数据库中「活跃事务」中事务 id 最小的事务，也就是 m_ids 的最小值。
• max_trx_id ：这个并不是 m_ids 的最大值，而是创建 Read View 时当前数据库中应该给下一个事务的 id 值，也就是全局事务中最大的事务 id 值 + 1；
• creator_trx_id ：指的是创建该 Read View 的事务的事务 id。

使用 InnoDB 存储引擎的数据库表，它的聚簇索引记录中都包含下面两个隐藏列：

• trx_id，当一个事务对某条聚簇索引记录进行改动时，就会把该事务的事务 id 记录在 trx_id 隐藏列里；
• roll_pointer，每次对某条聚簇索引记录进行改动时，都会把旧版本的记录写入到 undo 日志中，然后这个隐藏列是个指针，指向每一个旧版本记录，于是就可以通过它找到修改前的记录。
• 在创建 Read View 后，我们可以将记录中的 trx_id 划分这三种情况：

一个事务去访问记录的时候，除了自己的更新记录总是可见之外，还有这几种情况：

• 如果记录的 trx_id 值小于 Read View 中的 min_trx_id 值，表示这个版本的记录是在创建 Read View 前已经提交的事务生成的，所以该版本的记录对当前事务可见。
• 如果记录的 trx_id 值大于等于 Read View 中的 max_trx_id 值，表示这个版本的记录是在创建 Read View 后才启动的事务生成的，所以该版本的记录对当前事务不可见。
• 如果记录的 trx_id 值在 Read View 的 min_trx_id 和 max_trx_id 之间，需要判断 trx_id 是否在 m_ids 列表中：
  • 如果记录的 trx_id 在 m_ids 列表中，表示生成该版本记录的活跃事务依然活跃着（还没提交事务），所以该版本的记录对当前事务不可见。
  • 如果记录的 trx_id 不在 m_ids列表中，表示生成该版本记录的活跃事务已经被提交，所以该版本的记录对当前事务可见。

roll_pointer:中有个undo log日志

• 回滚日志，用于记录数据被修改前的信息 , 作用包含两个 : 提供回滚 和 MVCC(多版本并发控制) 。undo log和redo log记录物理日志不一样，它是逻辑日志。
• 可以认为当delete一条记录时，undo log中会记录一条对应的insert记录，反之亦然，
  当update一条记录时，它记录一条对应相反的update记录。当执行rollback时，就可以从undo log中的逻辑记录读取到相应的内容并进行回滚。

undo log和redo log的区别

• redo log: 记录的是数据页的物理变化，服务宕机可用来同步数据
• undo log ：记录的是逻辑日志，当事务回滚时，通过逆操作恢复原来的数据
• redo log保证了事务的持久性，undo log保证了事务的原子性和一致性

5.可重复读是怎么工作的

id	name	balance	trx_id	roll_pointer
1	小王	100000	50	o

• 在可重复读隔离级别下，事务 A 和事务 B 按顺序执行了以下操作：
• 事务 B 读取小林的账户余额记录，读到余额是 100 万；
• 事务 A 将小林的账户余额记录修改成 200 万，并没有提交事务；
• 事务 B 读取小林的账户余额记录，读到余额还是 100 万；
• 事务 A 提交事务；
• 事务 B 读取小林的账户余额记录，读到余额依然还是 100 万；
  事务 B 第一次读小林的账户余额记录，在找到记录后，它会先看这条记录的 trx_id，此时发现 trx_id 为 50，比事务 B 的 Read View 中的 min_trx_id 值（51）还小，这意味着修改这条记录的事务早就在事务 B 启动前提交过了，所以该版本的记录对事务 B 可见的，也就是事务 B 可以获取到这条记录。

接下来修改金额为200000

id	name	balance	trx_id	roll_pointer
1	小王	200000	51	o

由于事务 A 修改了该记录，以前的记录就变成旧版本记录了，于是最新记录和旧版本记录通过链表的方式串起来，而且最新记录的 trx_id 是事务 A 的事务 id（trx_id = 51）。

• 然后事务 B 第二次去读取该记录，发现这条记录的 trx_id 值为 51，在事务 B 的 Read View 的 min_trx_id 和 max_trx_id 之间，则需要判断 trx_id 值是否在 m_ids 范围内，判断的结果是在的，那么说明这条记录是被还未提交的事务修改的，这时事务 B 并不会读取这个版本的记录。而是沿着 undo log 链条往下找旧版本的记录，直到找到 trx_id 「小于」事务 B 的 Read View 中的 min_trx_id 值的第一条记录，所以事务 B 能读取到的是 trx_id 为 50 的记录，也就是小往余额是 100 万的这条记录。
• 最后，当事物 A 提交事务后，由于隔离级别时「可重复读」，所以事务 B 再次读取记录时，还是基于启动事务时创建的 Read View 来判断当前版本的记录是否可见。所以，即使事物 A 将小往余额修改为 200 万并提交了事务， 事务 B 第三次读取记录时，读到的记录都是小往余额是 100 万的这条记录。

6.读提交是如何工作的

读提交隔离级别是在每次读取数据时，都会生成一个新的 Read View。

也意味着，事务期间的多次读取同一条数据，前后两次读的数据可能会出现不一致，因为可能这期间另外一个事务修改了该记录，并提交了事务。

那读提交隔离级别是怎么工作呢？我们还是以前面的例子来聊聊。

假设事务 A （事务 id 为51）启动后，紧接着事务 B （事务 id 为52）也启动了，接着按顺序执行了以下操作：

• 事务 B 读取数据（创建 Read View），小王的账户余额为 100 万；
• 事务 A 修改数据（还没提交事务），将小王的账户余额从 100 万修改成了 200 万；
• 事务 B 读取数据（创建 Read View），小王的账户余额为 100 万；
• 事务 A 提交事务；
• 事务 B 读取数据（创建 Read View），小王的账户余额为 200 万；

我们来分析下为什么事务 B 第二次读数据时，读不到事务 A （还未提交事务）修改的数据？

事务 B 在找到小王这条记录时，会看这条记录的 trx_id 是 51，在事务 B 的 Read View 的 min_trx_id 和 max_trx_id 之间，接下来需要判断 trx_id 值是否在 m_ids 范围内，判断的结果是在的，那么说明这条记录是被还未提交的事务修改的，这时事务 B 并不会读取这个版本的记录。而是，沿着 undo log 链条往下找旧版本的记录，直到找到 trx_id 「小于」事务 B 的 Read View 中的 min_trx_id 值的第一条记录，所以事务 B 能读取到的是 trx_id 为 50 的记录，也就是小王余额是 100 万的这条记录。

我们来分析下为什么事务 A 提交后，事务 B 就可以读到事务 A 修改的数据？

在事务 A 提交后，由于隔离级别是「读提交」，所以事务 B 在每次读数据的时候，会重新创建 Read View，此时事务 B 第
三次读取数据时创建的 Read View

事务 B 在找到小王这条记录时，会发现这条记录的 trx_id 是 51，比事务 B 的 Read View 中的 min_trx_id 值（52）还小，这意味着修改这条记录的事务早就在创建 Read View 前提交过了，所以该版本的记录对事务 B 是可见的。

正是因为在读提交隔离级别下，事务每次读数据时都重新创建 Read View，那么在事务期间的多次读取同一条数据，前后两次读的数据可能会出现不一致，因为可能这期间另外一个事务修改了该记录，并提交了事务。

总结

事务是在 MySQL 引擎层实现的，我们常见的 InnoDB 引擎是支持事务的，事务的四大特性是原子性、一致性、隔离性、持久性，我们这次主要讲的是隔离性。

当多个事务并发执行的时候，会引发脏读、不可重复读、幻读这些问题，那为了避免这些问题，SQL 提出了四种隔离级别，分别是读未提交、读已提交、可重复读、串行化，从左往右隔离级别顺序递增，隔离级别越高，意味着性能越差，InnoDB 引擎的默认隔离级别是可重复读。

要解决脏读现象，就要将隔离级别升级到读已提交以上的隔离级别，要解决不可重复读现象，就要将隔离级别升级到可重复读以上的隔离级别。

而对于幻读现象，不建议将隔离级别升级为串行化，因为这会导致数据库并发时性能很差。MySQL InnoDB 引擎的默认隔离级别虽然是「可重复读」，但是它很大程度上避免幻读现象（并不是完全解决了，详见这篇文章 (opens new window)），解决的方案有两种：

针对快照读（普通 select 语句），是通过 MVCC 方式解决了幻读，因为可重复读隔离级别下，事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，即使中途有其他事务插入了一条数据，是查询不出来这条数据的，所以就很好了避免幻读问题。
针对当前读（select … for update 等语句），是通过 next-key lock（记录锁+间隙锁）方式解决了幻读，因为当执行 select … for update 语句的时候，会加上 next-key lock，如果有其他事务在 next-key lock 锁范围内插入了一条记录，那么这个插入语句就会被阻塞，无法成功插入，所以就很好了避免幻读问题。
对于「读提交」和「可重复读」隔离级别的事务来说，它们是通过 Read View 来实现的，它们的区别在于创建 Read View 的时机不同：

「读提交」隔离级别是在每个 select 都会生成一个新的 Read View，也意味着，事务期间的多次读取同一条数据，前后两次读的数据可能会出现不一致，因为可能这期间另外一个事务修改了该记录，并提交了事务。
「可重复读」隔离级别是启动事务时生成一个 Read View，然后整个事务期间都在用这个 Read View，这样就保证了在事务期间读到的数据都是事务启动前的记录。
这两个隔离级别实现是通过「事务的 Read View 里的字段」和「记录中的两个隐藏列」的比对，来控制并发事务访问同一个记录时的行为，这就叫 MVCC（多版本并发控制）。

在可重复读隔离级别中，普通的 select 语句就是基于 MVCC 实现的快照读，也就是不会加锁的。而 select … for update 语句就不是快照读了，而是当前读了，也就是每次读都是拿到最新版本的数据，但是它会对读到的记录加上 next-key lock 锁。