从原子性到串行化：数据库事务全解

编辑

一、前言

[6.1 事务的开始与回滚](#6.1 事务的开始与回滚)

七、事务的隔离性

[7.1 隔离级别的设置与查看](#7.1 隔离级别的设置与查看)

[7.1.1 全局隔离级别](#7.1.1 全局隔离级别)

[7.1.2 会话隔离级别](#7.1.2 会话隔离级别)

[7.2 四种隔离级别](#7.2 四种隔离级别)

[7.2.1 读未提交](#7.2.1 读未提交)

[7.2.2 读提交](#7.2.2 读提交)

[7.2.3 可重复读](#7.2.3 可重复读)

[7.2.4 串行化](#7.2.4 串行化)

一、前言

在接触MySQL的初期我们就学习了MySQL的CURD操作，但是这里就引入了一个问题：MySQL的CURD不加以控制就会出现类似多线程那样的数据不一致问题。

例如，假设MySQL中存在一个tickets表其中有一个车票的个数仅剩一个，此时有两个客户端同时抢票此时很可能会发生下面的情况：

客户端A判断票数大于0进入if，但是刚进入if就被调度此时客户端B的进程被调度运行，客户端B判断票数大于0也进入if执行抢票（此时剩余票数为0）。但是当客户端A再次被调度运行的时候会再一次进行抢票操作将票数抢到负数（因为它本身就在if分支之中）此时就会导致数据不一致问题。

那为了解决CURD操作可能导致的数据不一致问题我们就必须对其加以控制。以上述为例，CURD操作必须满足以下属性：

买票的过程得是原子的吧
买票互相应该不能影响吧
买完票应该要永久有效吧
买前，和买后都要是确定的状态吧

这样我们就引入了事务的概念：

二、什么是事务

事务就是一组DML语句组成，这些语句在逻辑上存在相关性，这一组DML语句要么全部成功，要么全部失败，是一个整体。MySQL提供一种机制，保证我们达到这样的效果。

事务还规定不同的客户端看到的数据是不相同的。事务就是要做的或所做的事情，主要用于处理操作量大，复杂度高的数据。假设一种场景：你毕业了，学校的教务系统后台 MySQL 中，不在需要你的数据，要删除你的所有信息(一般不会) 那么要删除你的基本信息(姓名，电话，籍贯等)的同时，也删除和你有关的其他信息，比如：你的各科成绩，你在校表现，甚至你在论坛发过的文章等。这样，就需要多条 MySQL 语句构成，那么所有这些操作合起来，就构成了一个事务。正如我们上面所说，一个 MySQL 数据库，可不止你一个事务在运行，同一时刻，甚至有大量的请求被包装成事务，在向 MySQL 服务器发起事务处理请求。而每条事务至少一条 SQL ，最多很多 SQL ,这样如果大家都访问同样的表数据，在不加保护的情况，就绝对会出现问题。甚至，因为事务由多条 SQL 构成，那么，也会存在执行到一半出错或者不想再执行的情况，那么已经执行的怎么办呢？所有，一个完整的事务，绝对不是简单的 sql 集合，还需要满足如下四个属性：

原子性 ：一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

一致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（ Read （S uncommitted ）、读提交（ read committed）、可重复读（ erializable ） repeatable read）和串行化

持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

上面四个属性，可以简称为 ACID 。

原子性（Atomicity，或称不可分割性）
一致性（Consistency）
隔离性（Isolation，又称独立性）
持久性（Durability）。

三、为什么会出现事务

事务被 MySQL 编写者设计出来,本质是为了当应用程序访问数据库的时候,事务能够简化我们的编程模型, 不需要我们去考虑各种各样的潜在错误和并发问题。可以想一下当我们使用事务时，要么提交，要么回滚，我们不会去考虑网络异常了，服务器宕机了，同时更改一个数据怎么办对吧？此事务本质上是为了应用层服务的，而不是伴随着数据库系统天生就有的

四、事务的版本支持

在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务，MyISAM 不支持。

查看数据库引擎：

bash 复制代码

-- 表格显示
show engines;
-- 行显示
show engines \G;

该命令的查询结果列出了当前 MySQL 服务器支持的所有存储引擎（Storage Engines），以及它们的特性支持情况。下面逐列解释各列的含义：

Engine（引擎） ：存储引擎的名称，如 InnoDB, MyISAM, MEMORY等。

Support（支持状态）：表示该引擎在当前 MySQL 实例中是否可用

YES：支持并可用。
DEFAULT：当前默认引擎（通常是 InnoDB）。
NO：不支持或未编译进 MySQL。
DISABLED：支持但被禁用（如配置文件中 skip-innodb）。
NULL：未启用或不支持（如 FEDERATED 在本例中显示 NO，但 Transactions/XA/Savepoints 为 NULL，说明不支持事务）。

Comment（注释/描述）：对该引擎的简要功能描述。

Transactions（事务支持） ：是否支持 ACID 事务。

YES：支持事务（如 InnoDB）。
NO：不支持事务（如 MyISAM、MEMORY）。
NULL：该引擎本身不支持事务（如 FEDERATED）。

XA（分布式事务支持）：是否支持 XA 分布式事务（两阶段提交协议）。

YES：支持（如 InnoDB）。
NO：不支持。
NULL：不支持或不可用。

Savepoints（保存点支持）：是否支持事务中的保存点，允许部分回滚。

YES：支持（如 InnoDB）。
NO：不支持。
NULL：不支持。

五、事务的提交方式

事务的提交方式常见的有两种：

自动提交
手动提交

查看事务提交方式

bash 复制代码

show variables like 'autocommit';

可以使用 SET 来改变 MySQL 的自动提交模式:

bash 复制代码

-- 关闭自动提交
SET AUTOCOMMIT=0;
-- 开启自动提交
SET AUTOCOMMIT=1;

六、事务的常见操作方式

6.1 事务的开始与回滚

首先我们创建一个测试表：

bash 复制代码

create table if not exists account(
id int primary key, 
name varchar(50) not null default '', 
blance decimal(10,2) not null default 0.0
)ENGINE=InnoDB DEFAULT CHARSET=UTF8;

查看事务的隔离级别并将事务的隔离级别设置为读未提交，关于事务的隔离性我们在下一节详细了解。

bash 复制代码

-- 将事务的隔离级别设置为读未提交
set global transaction isolation level READ UNCOMMITTED;
-- 查看事务的隔离级别（设置完成后需要重启终端）
select @@tx_isolation;

我们可以使用以下命令开启一个事务和提交并结束一个事务：

bash 复制代码

-- 开启一个事务
start transaction;
begin;

-- 提交并结束事务
commit;

当事务执行过程中发生错误或主动放弃时，撤销已经执行的 SQL 操作，把数据恢复到事务开始前的状态。其主要分为两钟类型：全部回滚与部分回滚，对应的命令如下：

bash 复制代码

-- 全部回滚
rollback;
-- 部分回滚，需要搭配自定义保存点使用
rollback to 保存点;

-- 设置保存点
savepoint 保存点名称;

需要注意的是完全回滚时会撤销整个事务并结束事务，所以此时可以使用commit提交也可以不使用，但是部分回滚事务结束后需要commit。

了解了事务的基本操作后，我们就可以对测试表进行简单的事务操作：

bash 复制代码

mysql> begin;                            -- 开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql> savepoint save1;                  -- 设置一个保存点save1
Query OK, 0 rows affected (0.00 sec)

mysql> insert into account values (1, '张三', 100);  --插入一条数据
Query OK, 1 row affected (0.01 sec)

mysql> savepoint save2;                  -- 设置一个保存点save2
Query OK, 0 rows affected (0.00 sec)

mysql> insert into account values (2, '李四', 10000);  --插入一条数据
Query OK, 1 row affected (0.00 sec)

mysql> select * from account;            -- 此时表中一共有两条数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

mysql>  rollback to save2;               -- 回滚到保存点save2
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;            -- 此时表中只剩一条数据
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

mysql>  rollback;                        -- 完全回滚
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;            -- 此时表中一条数据都没有了
Empty set (0.00 sec)

mysql> commit;                           -- 提交并结束日志

非正常演示1 - 证明未commit，客户端崩溃，MySQL自动会回滚（隔离级别设置为读未提交）

bash 复制代码

-- 终端A
mysql> select * from account;                -- 开始表中没有数据
Empty set (0.00 sec)

mysql> show variables like 'autocommit';     -- 提交方式是自动提交
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.03 sec)

mysql> begin;                                 -- 开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql>  insert into account values (1, '张三', 100);  --向表中插入一条数据
Query OK, 1 row affected (0.01 sec)

mysql> select * from account;           -- 此时表中被插入了一条数据，然后同时在终端B中查看数据
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.01 sec)
-- 终端B                        -- 因为隔离性是读未提交所以终端B也可以看到终端A向表中插入的数据
mysql> select * from account;
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)
-- 终端A

mysql> Aborted                             -- Ctrl+\异常终止终端A，同时在终端B中查看数据情况
-- 终端B
mysql> select * from account;              -- 此时事务被自动回滚
Empty set (0.00 sec)

非正常演示2 - 证明commit了，客户端崩溃，MySQL数据不会在受影响，已经持久化

bash 复制代码

--终端A
mysql>  show variables like 'autocommit'; -- 依旧自动提交
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.01 sec)

mysql>  select * from account;   -- 当前表内无数据
Empty set (0.00 sec)

mysql> begin;                   -- 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql>  insert into account values (1, '张三', 100); -- 插入记录
Query OK, 1 row affected (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

mysql> Aborted
-- 终端B
mysql> select * from account;       -- 数据已经存在了，所以commit的作用是将数据持久化到MySQL中国
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

非正常演示3 - 对比试验。证明begin操作会自动更改提交方式，不会受MySQL是否自动提交影响

bash 复制代码

mysql> show tables;
+------------------+
| Tables_in_mytest |
+------------------+
| account          |
+------------------+
1 row in set (0.00 sec)

-- 终端A
mysql>  show variables like 'autocommit';   --查看事务提交方式
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.00 sec)
mysql>  set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> show variables like 'autocommit';   --查看关闭之后结果
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | OFF   |
+---------------+-------+
1 row in set (0.00 sec)
mysql>  begin;                              -- 开启事务
Query OK, 0 rows affected (0.00 sec)

mysql>  insert into account values (2, '李四', 10000);     --插入一条数据
Query OK, 1 row affected (0.00 sec)

mysql> select *from account;      -- 查看插入后的结果，同时终端B查询表
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

--终端B
mysql> select * from account;
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

-- 终端A
mysql> Aborted                   -- Ctrl+\ 模拟异常终止
-- 终端B
mysql> select * from account;    -- 再次查询发现数据已经回滚
+----+--------+--------+ 
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

非正常演示4 - 证明单条 SQL 与事务的关系

实验一：

cpp 复制代码

-- 终端A
mysql> select * from account;              -- 插入前表中的数据
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

mysql> show variables like 'autocommit'; 
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.00 sec)

mysql> set autocommit=0;                    -- 关闭自动提交
Query OK, 0 rows affected (0.00 sec)

mysql> insert into account values (2, '李四', 10000);   --插入一条数据
Query OK, 1 row affected (0.00 sec)

mysql> select *from account;                -- 查询发现数据已经成功插入，同时在终端B也查询表
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)
-- 终端B
mysql> select * from account;            -- 终端B也查询到了新增数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)
-- 终端A
mysql> Aborted                           -- Ctrl+\模拟异常终止
-- 终端B
mysql> select * from account;            -- 发现单挑SQL也会像事务一样发生自动回滚
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

实验二：

cpp 复制代码

-- 终端A
mysql> show variables like 'autocommit';  -- 开启自动提交
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.01 sec)

mysql> select * from account;             -- 插入前表中的数据
+----+--------+--------+
| id | name   | blance |
+----+--------+--------+
|  1 | 张三   | 100.00 |
+----+--------+--------+
1 row in set (0.00 sec)

mysql> insert into account values (2, '李四', 10000);  -- 插入一条数据记录
Query OK, 1 row affected (0.00 sec)

mysql> select *from account;   -- 数据已经成功插入，此时查看终端B
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

-- 终端B
mysql> select * from account;
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)
-- 终端A
mysql> Aborted                  -- Ctrl+\ 模拟异常终止
-- 终端B
mysql> select * from account;   -- 数据已经自动提交，并不影响，已经持久化
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   100.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+

总结一下：

只要输入begin或者start transaction，事务便必须要通过commit提交，才会持久化，与是否设置set autocommit无关。
事务可以手动回滚，同时，当操作异常，MySQL会自动回滚
对于InnoDB 每一条 SQL 语言都默认封装成事务，自动提交。（select有特殊情况，因为 MySQL 有 MVCC ）

事务操作的注意事项：

如果没有设置保存点，也可以回滚，只能回滚到事务的开始。
直接使用 rollback(前提是事务还没有提交) 如果一个事务被提交了（commit），则不可以回退（rollback）可以选择回退到哪个保存点
InnoDB 支持事务， MyISAM 不支持事务
开始事务可以使 start transaction 或者 begin

七、事务的隔离性

MySQL服务可能会同时被多个客户端进程(线程)访问，访问的方式以事务方式进行一个事务可能由多条SQL构成，也就意味着，任何一个事务，都有执行前，执行中，执行后的阶段。而所谓的原子性，其实就是让用户层，要么看到执行前，要么看到执行后。执行中出现问题，可以随时回滚。所以单个事务，对用户表现出来的特性，就是原子性。但，毕竟所有事务都要有个执行过程，那么在多个事务各自执行多个SQL的时候，就还是有可能会出现互相影响的情况。比如：多个事务同时访问同一张表，甚至同一行数据。

就如同你妈妈给你说：你要么别学，要学就学到最好。至于你怎么学，中间有什么困难，你妈妈不关心。那么你的学习，对你妈妈来讲，就是原子的。那么你学习过程中，很容易受别人干扰，此时，就需要将你的学习隔离开，保证你的学习环境是健康的。

数据库中，为了保证事务执行过程中尽量不受干扰，就有了一个重要特征：隔离性

数据库中，允许事务受不同程度的干扰，就有了一种重要特征：隔离级别

在MySQL中事务的隔离级别主要分为以下四种：

读未提交【Read Uncommitted】：在该隔离级别，所有的事务都可以看到其他事务没有提交的执行结果。（实际生产中不可能使用这种隔离级别的），但是相当于没有任何隔离性，也会有很多并发问题，如脏读，幻读，不可重复读等，我们上面为了做实验方便，用的就是这个隔离性。

读提交【Read Committed】 ：该隔离级别是大多数数据库的默认的隔离级别（不是 MySQL 默认的）。它满足了隔离的简单定义:一个事务只能看到其他的已经提交的事务所做的改变。这种隔离级别会引起不可重复读，即一个事务执行时，如果多次 select，可能得到不同的结果。

可重复读【Repeatable Read】：这是 MySQL 默认的隔离级别，它确保同一个事务，在执行中，多次读取操作数据时，会看到同样的数据行。但是会有幻读问题。

串行化【Serializable】: 这是事务的最高隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决了幻读的问题。它在每个读的数据行上面加上共享锁，。但是可能会导致超时和锁竞争（这种隔离级别太极端，实际生产基本不使用）

7.1 隔离级别的设置与查看

在MySQL中事务的隔离级别分为两种：全局隔离级别+会话隔离级别

7.1.1 全局隔离级别

全局隔离级别指数据库服务器层面的默认事务隔离级别，对所有新建立的连接生效（除非连接自己再单独修改）。

可以理解为：

数据库的"出厂默认隔离级别"

作用于：所有新的数据库连接（会话）
不自动影响：已经存在的会话

在MySQL中我们可以通过以下命令来查看与设置全局隔离级别：

bash 复制代码

-- 查看当前全局隔离级别
SELECT @@global.transaction_isolation;

-- 设置全局隔离级别（需要管理员权限）
SET GLOBAL transaction_isolation = 'REPEATABLE-READ';
SET GLOBAL transaction isolation level REPEATABLE-READ;

需要注意的是

注意：

全局隔离级别需要写入配置文件（如 my.cnf）才能永久生效
修改后，已有连接不会变，只对之后新建的连接生效

7.1.2 会话隔离级别

会话隔离级别：指某个具体数据库连接（session）自身的事务隔离级别。

可以理解为：

某个连接的"个性化隔离级别设置"

只作用于：当前数据库连接
优先级：高于全局隔离级别
不影响：其他连接或全局默认值

在MySQL中我们可以通过以下命令来查看与设置会话隔离级别：

bash 复制代码

-- 查看当前会话隔离级别
SELECT @@session.transaction_isolation;

-- 设置当前会话隔离级别
SET SESSION transaction_isolation = 'READ-COMMITTED';
SET SESSION transaction isolation level REPEATABLE-READ;

该设置在当前连接断开前一直有效。需要注意的是：会话隔离级别 = 会话显式设置的值或建立连接时的全局默认值

当客户端建立连接时：如果会话未显式设置隔离级别会自动继承当前的 全局隔离级别。

7.2 四种隔离级别

7.2.1 读未提交

事务可以读取其他事务尚未提交的数据。

cpp 复制代码

-- 终端A
mysql> SELECT @@session.transaction_isolation;   --查看当前会话隔离级别
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-UNCOMMITTED                |
+---------------------------------+
1 row in set (0.00 sec)

mysql> select * from account;         -- 当前表中数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   123.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

mysql> begin;                         -- 开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql> update account set blance=333.0 where id=1;    -- 指定更新行，同时在终端B中查看此表
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql>                               -- 终端A未提交
-- 终端B
mysql> select * from account;         -- 终端B查看到了终端A未提交的数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   333.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

mysql>

一个事务在执行中，读到另一个执行中事务的更新(或其他操作)但是未commit的数据，这种现象叫做脏读 (dirty read)

7.2.2 读提交

事务只能读取其他事务已经提交的数据。

bash 复制代码

--终端A
mysql> SELECT @@session.transaction_isolation;  -- 查看当前会话隔离级别
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-COMMITTED                  |
+---------------------------------+
1 row in set (0.00 sec)

mysql> select * from account;                   -- 表中原先的数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   123.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

mysql> begin;                                   -- 开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql> update account set blance=321.0 where id=1;  -- 更新指定行，此时事务未提交转到终端B查询数据
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

-- 终端B
mysql> select * from account;                   -- 终端B查询到的还是旧数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   123.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

-- 终端A，commit事务
mysql> commit;
Query OK, 0 rows affected (0.01 sec)

-- 此时，终端B可以看到修改后的新数据了
mysql> select * from account;
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   321.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

对终端B来讲，同样的读取，在不同的时间段 (依旧还在事务操作中！)，读取到了不同的值，这种现象叫做不可重复读(non reapeatable read)。

7.2.3 可重复读

同一事务中，多次读取同一行数据，结果一致（不受其他事务提交影响）。

bash 复制代码

-- 终端B
mysql> SELECT @@session.transaction_isolation;   -- 查看当前会话隔离级别
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| REPEATABLE-READ                 |
+---------------------------------+
1 row in set (0.00 sec)

mysql> begin;                                    -- 开启一个事务，终端B也同步开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;                    -- 表中的原数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   321.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
mysql> update account set blance=4321.0 where id=1;     -- 更改指定行，此时终端查询表数据
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
-- 终端B
mysql> begin;                                    -- 终端B同步开启一个事务
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;                    -- 终端B查询表读取到的还是旧数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   321.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

--终端A
mysql> commit;                                   -- 终端A提交事务后终端B再次查询表数据
Query OK, 0 rows affected (0.01 sec)

--终端B
mysql> select * from account;                    -- 终端B查询到的还是旧数据
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |   321.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

可以看到，在终端B中，当前事务无论什么时候进行查找，看到的结果都是一致的，这叫做可重复读！当终端B结束当前事务并开启一个新事务后才能看到终端Acommit后的新数据：

cpp 复制代码

mysql> commit;                         -- 终端B结束当前事务
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;          -- 重新查询表数据，此时就等于新开了一个事务可以看到新数据了
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |  4321.00 |
|  2 | 李四   | 10000.00 |
+----+--------+----------+
2 rows in set (0.00 sec)

这里需要注意的一点是：一般的数据库在可重复读情况的时候，无法屏蔽其他事务insert的数据(为什么？因为隔离性实现是对数据加锁完成的，而insert待插入的数据因为并不存在，那么一般加锁无法屏蔽这类问题),会造成虽然大部分内容是可重复读的，但是insert的数据在可重复读情况被读取出来，导致多次查找时，会多查找出来新的记录，就如同产生了幻觉。这种现象，叫做幻读 (phantom read)。MySQL在RR级别的时候，是解决了幻读问题的(解决的方式是用Next-Key锁 (GAP+行锁)解决的。

7.2.4 串行化

事务完全串行执行，等价于事务一个接一个运行。

bash 复制代码

--终端A
mysql> set global transaction isolation level serializable;
Query OK, 0 rows affected (0.00 sec)

mysql> select @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| SERIALIZABLE   |
+----------------+
1 row in set, 1 warning (0.00 sec)

mysql> begin;                        --开启事务，终端B同步开启
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;        --两个读取不会串行化，共享锁
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |  4321.00 |
|  2 | 李四   | 10000.00 |
|  3 | 王五   |  5432.00 |
+----+--------+----------+
3 rows in set (0.00 sec)

mysql> update account set blance=1.00 where id=1; --终端A中有更新或者其他操作，会阻
塞。直到终端B事务提交。
Query OK, 1 row affected (18.19 sec)
Rows matched: 1  Changed: 1  Warnings: 0

--终端B
mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;    
+----+--------+----------+
| id | name   | blance   |
+----+--------+----------+
|  1 | 张三   |  4321.00 |
|  2 | 李四   | 10000.00 |
|  3 | 王五   |  5432.00 |
+----+--------+----------+
3 rows in set (0.00 sec)
mysql> commit;                             --提交之后，终端A中的update才会提交。
Query OK, 0 rows affected (0.00 sec)

上述示例可以用一张图片表示：客户端A发送了一个 select查询请求给 DBMS。因为处于可串行化级别，为了保证A后续再次读取时数据不变（防止幻读），DBMS 不仅读取了数据，还对 account表（或相关的数据范围）加了锁（图中"锁"指向 account）。

客户端B试图发送 update更新请求。但是，由于A已经持有了锁，B的请求无法直接操作数据。此时B 的请求被 DBMS 拦截，放入了等待队列。意味着如果 A 的事务一直不结束（不提交也不回滚），锁一直不释放，B 就会一直等下去，直到超过了数据库设定的等待超时时间。

串行化在这里不是指电脑死机，而是指"顺序化"。DBMS 通过加锁，强制让本来可以并行的 A 和 B 变成了"A 先做，B 等着"这种串行（排队）的状态。如果 A 提交了，锁释放，B 才能继续执行；或者 A 回滚了，B 也可能继续。但如果 B 等不及超时了，DBMS 就会报错终止 B 的操作。