MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别

MySQL 从零入门(九):事务管理详解------ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别


🔥 星恒随风: 个人主页 ❄️ 个人专栏: 《Linux网络编程从0到1》 | 《C语言基础》 | 《数据结构和算法》 | 《MySQL入门心法》 | 《前端基础》 | 《python基础》 | 《C++从入门到入土》 | 《Linux系统编程》 ✨ 数据即知识,压缩即智能


文章目录

  • [MySQL 从零入门(九):事务管理详解------ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别](#MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别)
  • 一、什么是事务?
    • [1.1 事务的基本概念](#1.1 事务的基本概念)
    • [1.2 为什么需要事务?](#1.2 为什么需要事务?)
  • [二、事务的 ACID 四大特性](#二、事务的 ACID 四大特性)
    • [2.1 原子性(Atomicity)](#2.1 原子性(Atomicity))
    • [2.2 一致性(Consistency)](#2.2 一致性(Consistency))
    • [2.3 隔离性(Isolation)](#2.3 隔离性(Isolation))
    • [2.4 持久性(Durability)](#2.4 持久性(Durability))
  • [三、哪些 MySQL 存储引擎支持事务?](#三、哪些 MySQL 存储引擎支持事务?)
    • [3.1 查看存储引擎](#3.1 查看存储引擎)
    • [3.2 为什么不能用 MyISAM 演示回滚?](#3.2 为什么不能用 MyISAM 演示回滚?)
  • 四、事务的提交方式
    • [4.1 查看 autocommit](#4.1 查看 autocommit)
    • [4.2 关闭自动提交](#4.2 关闭自动提交)
    • [4.3 开启自动提交](#4.3 开启自动提交)
    • [4.4 BEGIN 与 AUTOCOMMIT 有什么关系?](#4.4 BEGIN 与 AUTOCOMMIT 有什么关系?)
  • [五、事务常见操作:BEGIN、COMMIT 与 ROLLBACK](#五、事务常见操作:BEGIN、COMMIT 与 ROLLBACK)
    • [5.1 准备测试数据库](#5.1 准备测试数据库)
    • [5.2 BEGIN:开启事务](#5.2 BEGIN:开启事务)
    • [5.3 COMMIT:提交事务](#5.3 COMMIT:提交事务)
    • [5.4 ROLLBACK:回滚事务](#5.4 ROLLBACK:回滚事务)
  • 六、SAVEPOINT:事务保存点
    • [6.1 什么是保存点?](#6.1 什么是保存点?)
    • [6.2 完整实验](#6.2 完整实验)
    • [6.3 ROLLBACK 与 ROLLBACK TO 的区别](#6.3 ROLLBACK 与 ROLLBACK TO 的区别)
    • [6.4 COMMIT 后还能回滚吗?](#6.4 COMMIT 后还能回滚吗?)
  • 七、事务异常退出会发生什么?
    • [7.1 未提交事务与连接断开](#7.1 未提交事务与连接断开)
    • [7.2 已提交事务与连接断开](#7.2 已提交事务与连接断开)
  • [八、单条 SQL 与事务的关系](#八、单条 SQL 与事务的关系)
    • [8.1 自动提交模式](#8.1 自动提交模式)
    • [8.2 关闭自动提交模式](#8.2 关闭自动提交模式)
    • [8.3 事务使用注意事项](#8.3 事务使用注意事项)
  • 九、什么是事务隔离性?
    • [9.1 多事务并发的三类问题](#9.1 多事务并发的三类问题)
    • [9.2 准备两个客户端](#9.2 准备两个客户端)
  • 十、四种事务隔离级别
    • [10.1 查看当前隔离级别](#10.1 查看当前隔离级别)
    • [10.2 修改当前会话的隔离级别](#10.2 修改当前会话的隔离级别)
    • [10.3 为什么不直接修改全局隔离级别?](#10.3 为什么不直接修改全局隔离级别?)
  • [十一、读未提交(READ UNCOMMITTED)](#十一、读未提交(READ UNCOMMITTED))
    • [11.1 什么是脏读?](#11.1 什么是脏读?)
    • [11.2 实验步骤](#11.2 实验步骤)
    • [11.3 为什么脏读危险?](#11.3 为什么脏读危险?)
  • [十二、读已提交(READ COMMITTED)](#十二、读已提交(READ COMMITTED))
    • [12.1 什么是读已提交?](#12.1 什么是读已提交?)
    • [12.2 什么是不可重复读?](#12.2 什么是不可重复读?)
    • [12.3 实验步骤](#12.3 实验步骤)
  • [十三、可重复读(REPEATABLE READ)](#十三、可重复读(REPEATABLE READ))
    • [13.1 什么是可重复读?](#13.1 什么是可重复读?)
    • [13.2 实验步骤](#13.2 实验步骤)
    • [13.3 一个重要问题:BEGIN 就创建快照了吗?](#13.3 一个重要问题:BEGIN 就创建快照了吗?)
  • [十四、什么是幻读(Phantom Read)?](#十四、什么是幻读(Phantom Read)?)
    • [14.1 幻读的基本概念](#14.1 幻读的基本概念)
    • [14.2 READ COMMITTED 下的幻读实验](#14.2 READ COMMITTED 下的幻读实验)
    • [14.3 MySQL 的可重复读能否避免幻读?](#14.3 MySQL 的可重复读能否避免幻读?)
  • 十五、串行化(SERIALIZABLE)
    • [15.1 什么是串行化?](#15.1 什么是串行化?)
    • [15.2 设置隔离级别](#15.2 设置隔离级别)
    • [15.3 简单并发实验](#15.3 简单并发实验)
    • [15.4 串行化的优缺点](#15.4 串行化的优缺点)
  • 十六、四种隔离级别总结
    • [16.1 三种并发读取问题的区别](#16.1 三种并发读取问题的区别)
  • 十七、事务的一致性与业务逻辑
  • 十八、常见问题总结
    • [18.1 BEGIN 和 START TRANSACTION 有什么区别?](#18.1 BEGIN 和 START TRANSACTION 有什么区别?)
    • [18.2 BEGIN 之后 autocommit 会自动变成 OFF 吗?](#18.2 BEGIN 之后 autocommit 会自动变成 OFF 吗?)
    • [18.3 SAVEPOINT 是否等于提交?](#18.3 SAVEPOINT 是否等于提交?)
    • [18.4 COMMIT 之后还能 ROLLBACK 吗?](#18.4 COMMIT 之后还能 ROLLBACK 吗?)
    • [18.5 事务能够包含 CREATE TABLE 吗?](#18.5 事务能够包含 CREATE TABLE 吗?)
    • [18.6 为什么需要两个 MySQL 连接实验?](#18.6 为什么需要两个 MySQL 连接实验?)
    • [18.7 MySQL 默认隔离级别是什么?](#18.7 MySQL 默认隔离级别是什么?)
  • [十九、常用事务 SQL 命令速查](#十九、常用事务 SQL 命令速查)
  • 二十、总结

前言

在前面的学习中,我们已经掌握了 MySQL 数据库的增删改查、内置函数、多表查询和索引原理。

但是,在真实的后端系统中,数据库操作往往不是独立进行的。

例如:用户在网上购买了一张火车票。

购买过程中可能需要完成:

  1. 查询剩余车票。
  2. 扣减剩余车票数量。
  3. 扣除用户账户余额。
  4. 生成订单。
  5. 更新订单状态。

这些操作可能需要执行多条 SQL。

如果前三步执行成功,但生成订单时发生错误,应该怎么办?

如果用户已经扣款,却没有获得车票,就会产生严重的业务问题。

因此,数据库需要一种机制,让多条相关 SQL 能够作为一个整体执行。

这就是 事务(Transaction)。

本文将从事务的基本概念开始,逐步介绍 ACID 四大特性、提交与回滚、保存点以及四种隔离级别。


一、什么是事务?

1.1 事务的基本概念

事务是数据库中一个逻辑工作单元。

一个事务可以包含一条或多条 SQL 操作。

从业务角度看,这些操作应该被视为一个整体:

要么全部成功并提交,要么在发生问题时撤销未提交的修改。

例如,银行转账:

张三向李四转账 100 元。

假设初始余额为:

用户 余额
张三 1000.00
李四 500.00

转账需要执行两条 SQL:

sql 复制代码
UPDATE account
SET balance = balance - 100
WHERE name = '张三';

UPDATE account
SET balance = balance + 100
WHERE name = '李四';

正常执行后:

用户 余额
张三 900.00
李四 600.00

总金额仍然为:

1000 + 500 = 900 + 600 = 1500 1000+500=900+600=1500 1000+500=900+600=1500

但如果第一条 SQL 执行成功,第二条 SQL 执行失败,就可能出现:

text 复制代码
张三:1000 → 900

李四:500 → 500

总金额从 1500 变成了 1400。

这显然违反转账业务规则。

事务可以使两条更新作为一个整体进行提交或回滚,避免只有其中一部分修改最终生效。

需要注意,实际银行系统还需要考虑并发控制、余额校验、审计及幂等性等问题,事务只是其中的重要基础。

1.2 为什么需要事务?

事务主要解决两类问题。

第一类:执行过程中发生错误。

例如:

text 复制代码
开始转账
    ↓
扣除张三100元
    ↓
增加李四100元
    ↓
提交事务

如果中间发生异常,数据库应能够撤销尚未提交的事务修改。

第二类:多个客户端同时操作数据库。

假设两个用户同时购买同一张剩余车票。

如果不考虑并发控制,两个操作可能都认为:

text 复制代码
剩余车票 = 1

最终发生超卖。

因此,事务不仅需要解决执行失败的问题,还需要考虑并发事务之间的相互影响。


二、事务的 ACID 四大特性

一个可靠的数据库事务应满足四项基本性质,简称 ACID。

图 1:ACID 四大特性示意图。图片来源:阿里云开发者社区。

ACID 分别代表:

字母 英文 中文
A Atomicity 原子性
C Consistency 一致性
I Isolation 隔离性
D Durability 持久性

下面逐个讲解。

2.1 原子性(Atomicity)

原子性表示:

一个事务中的操作作为不可分割的整体执行,不能只保留一部分未完成的事务修改。

例如:

sql 复制代码
BEGIN;

UPDATE account
SET balance = balance - 100
WHERE id = 1;

UPDATE account
SET balance = balance + 100
WHERE id = 2;

COMMIT;

这里的两条 UPDATE 属于同一个事务。

如果业务执行过程中出现错误,可以通过:

sql 复制代码
ROLLBACK;

撤销尚未提交的事务修改。

注意,原子性不意味着事务中每条 SQL 必须在同一瞬间执行,而是要求事务最终不能只保留不完整的操作结果。

2.2 一致性(Consistency)

一致性表示:

事务执行前和成功执行后,数据库应该满足预先定义的完整性约束及业务规则。

例如,转账前:

1000 + 500 = 1500 1000+500=1500 1000+500=1500

转账后:

900 + 600 = 1500 900+600=1500 900+600=1500

账户总金额没有凭空增加或减少。

这里需要注意:

一致性并不完全由 MySQL 自动保证。

例如,账户余额不能为负、订单金额必须正确等业务规则,仍需要应用程序和数据库约束共同实现。

可以理解为:

  • 原子性避免事务只执行一半。
  • 隔离性限制并发事务之间的不合理干扰。
  • 持久性保证已提交结果能够持久保存。
  • 业务代码和数据约束共同维护业务一致性。

2.3 隔离性(Isolation)

隔离性表示:

多个事务并发执行时,需要按照指定规则控制彼此的数据可见性和操作影响。

例如:

事务 A 正在修改一条账户记录,但尚未提交。

事务 B 能否看到这条未提交的修改?

这个问题由事务隔离级别决定。

MySQL 提供四种隔离级别:

text 复制代码
READ UNCOMMITTED
READ COMMITTED
REPEATABLE READ
SERIALIZABLE

不同隔离级别允许不同程度的并发可见性和并发操作。

2.4 持久性(Durability)

持久性表示:

事务成功提交后,数据库应能够在其承诺的故障恢复范围内保存事务结果。

例如:

sql 复制代码
BEGIN;

UPDATE account
SET balance = 900
WHERE id = 1;

COMMIT;

成功提交之后,即使客户端断开连接,数据库仍应保留已经提交的结果。

InnoDB 通过 Redo Log、日志刷盘和恢复机制等实现持久性。

不过,持久性保证还受到数据库刷盘配置和底层存储可靠性的影响。

例如:

sql 复制代码
SHOW VARIABLES LIKE 'innodb_flush_log_at_trx_commit';

该参数影响事务提交时 Redo Log 的刷盘策略。

因此,不能简单地把 COMMIT 理解为"每个数据页已经立即写入磁盘"。


三、哪些 MySQL 存储引擎支持事务?

MySQL 支持多种存储引擎。

常见的包括:

  • InnoDB
  • MyISAM
  • MEMORY

但并不是所有存储引擎都支持事务。

3.1 查看存储引擎

执行:

sql 复制代码
SHOW ENGINES;

这里:

  • SHOW:显示。
  • ENGINES:存储引擎。

重点关注结果中的:

text 复制代码
Engine
Transactions
Savepoints

例如:

存储引擎 事务 保存点
InnoDB 支持 支持
MyISAM 不支持 不支持
MEMORY 不支持 不支持

在 MySQL 5.7 中,InnoDB 是默认存储引擎。

因此,后续事务实验统一使用:

sql 复制代码
ENGINE=InnoDB

3.2 为什么不能用 MyISAM 演示回滚?

例如:

sql 复制代码
CREATE TABLE myisam_test (
    id INT PRIMARY KEY,
    name VARCHAR(20)
) ENGINE=MyISAM;

即使执行:

sql 复制代码
BEGIN;

INSERT INTO myisam_test
VALUES (1, '张三');

ROLLBACK;

也不能像 InnoDB 那样撤销对 MyISAM 表的修改。

原因是 MyISAM 不支持事务性回滚。

因此:

要验证事务的原子性、回滚和隔离行为,应使用支持事务的存储引擎。


四、事务的提交方式

MySQL 常见的提交方式包括:

  1. 自动提交。
  2. 手动提交。

4.1 查看 autocommit

执行:

sql 复制代码
SHOW VARIABLES LIKE 'autocommit';

默认通常返回:

text 复制代码
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+

这里的:

text 复制代码
autocommit = ON

表示当前连接启用了自动提交。

在没有显式事务的情况下,独立执行的事务性 SQL 通常会在语句成功后自动提交。

例如:

sql 复制代码
INSERT INTO account
VALUES (1, '张三', 100);

如果没有使用 BEGIN 或 START TRANSACTION,语句在自动提交模式下成功执行后,事务就会结束并提交。

4.2 关闭自动提交

sql 复制代码
SET AUTOCOMMIT = 0;

其中:

  • SET:设置系统变量。
  • AUTOCOMMIT:自动提交配置。
  • 0:关闭。

关闭后:

sql 复制代码
SHOW VARIABLES LIKE 'autocommit';

返回:

text 复制代码
autocommit = OFF

此时需要显式提交修改:

sql 复制代码
COMMIT;

或者撤销:

sql 复制代码
ROLLBACK;

4.3 开启自动提交

sql 复制代码
SET AUTOCOMMIT = 1;

恢复:

text 复制代码
autocommit = ON

需要注意:从 autocommit=0 切换到 autocommit=1 时,可能提交当前事务。

因此,不应该在存在未完成修改时随意切换该参数。

4.4 BEGIN 与 AUTOCOMMIT 有什么关系?

即使当前:

text 复制代码
autocommit = ON

执行:

sql 复制代码
BEGIN;

或者:

sql 复制代码
START TRANSACTION;

也会显式开启一个事务。

之后的事务性修改不会因为 autocommit 仍显示 ON 就逐条自动提交。

必须使用:

sql 复制代码
COMMIT;

或者:

sql 复制代码
ROLLBACK;

结束显式事务。

需要特别注意:

BEGIN 并不是永久修改 autocommit 系统变量,而是显式开启一个事务。

当事务结束后,原来的自动提交设置仍然有效。


五、事务常见操作:BEGIN、COMMIT 与 ROLLBACK

5.1 准备测试数据库

创建独立数据库:

sql 复制代码
CREATE DATABASE IF NOT EXISTS lab09
CHARACTER SET utf8;

USE lab09;

创建账户表:

sql 复制代码
CREATE TABLE account (
    id INT PRIMARY KEY,
    name VARCHAR(50) NOT NULL DEFAULT '',
    balance DECIMAL(10,2) NOT NULL DEFAULT 0.00
) ENGINE=InnoDB;

字段含义:

字段 作用
id 账户编号
name 用户姓名
balance 账户余额

其中:

sql 复制代码
DECIMAL(10,2)

用于保存精确的十进制金额。

5.2 BEGIN:开启事务

sql 复制代码
BEGIN;

也可以使用:

sql 复制代码
START TRANSACTION;

两者都可以显式开启事务。

5.3 COMMIT:提交事务

sql 复制代码
COMMIT;

表示提交当前事务,使事务修改正式生效。

5.4 ROLLBACK:回滚事务

sql 复制代码
ROLLBACK;

表示撤销当前事务中尚未提交的修改。

例如:

sql 复制代码
BEGIN;

INSERT INTO account
VALUES (1, '张三', 100.00);

ROLLBACK;

然后:

sql 复制代码
SELECT * FROM account;

如果开始事务前表为空,结果仍然为空。

说明插入被回滚了。


六、SAVEPOINT:事务保存点

6.1 什么是保存点?

如果一个事务包含多条 SQL,可能希望只撤销后面的部分修改,而不是回滚整个事务。

这时可以使用:

sql 复制代码
SAVEPOINT

保存点可以理解为事务执行过程中的一个标记。

例如:

text 复制代码
BEGIN
  │
  ▼
INSERT 张三
  │
  ▼
SAVEPOINT save1
  │
  ▼
INSERT 李四
  │
  ▼
SAVEPOINT save2
  │
  ▼
INSERT 王五
  │
  ▼
ROLLBACK TO save2

这样可以撤销创建 save2 之后的修改,而保留更早的修改。

6.2 完整实验

为了避免与前面账户表的数据混淆,创建独立测试表:

sql 复制代码
CREATE TABLE savepoint_demo (
    id INT PRIMARY KEY,
    name VARCHAR(20)
) ENGINE=InnoDB;

开启事务:

sql 复制代码
BEGIN;

创建保存点:

sql 复制代码
SAVEPOINT save1;

插入张三:

sql 复制代码
INSERT INTO savepoint_demo
VALUES (1, '张三');

创建第二个保存点:

sql 复制代码
SAVEPOINT save2;

插入李四:

sql 复制代码
INSERT INTO savepoint_demo
VALUES (2, '李四');

查询:

sql 复制代码
SELECT * FROM savepoint_demo;

当前事务能够看到:

text 复制代码
1 张三
2 李四

现在执行:

sql 复制代码
ROLLBACK TO SAVEPOINT save2;

再次查询:

sql 复制代码
SELECT * FROM savepoint_demo;

结果只剩:

text 复制代码
1 张三

原因是李四的记录在 save2 之后插入,因此被撤销。

然后执行:

sql 复制代码
ROLLBACK;

整个事务被回滚。

再次查询:

sql 复制代码
SELECT * FROM savepoint_demo;

结果为空。

6.3 ROLLBACK 与 ROLLBACK TO 的区别

指令 作用
ROLLBACK 回滚整个当前事务
ROLLBACK TO SAVEPOINT name 回滚到指定保存点
SAVEPOINT name 创建保存点
RELEASE SAVEPOINT name 删除指定保存点

例如:

sql 复制代码
RELEASE SAVEPOINT save1;

用于移除保存点。

注意,释放保存点不等于提交事务。

6.4 COMMIT 后还能回滚吗?

通常不能。

例如:

sql 复制代码
BEGIN;

INSERT INTO savepoint_demo
VALUES (1, '张三');

COMMIT;

然后再执行:

sql 复制代码
ROLLBACK;

不会撤销刚才已经成功提交的插入。

另外,CREATE TABLE、DROP TABLE、TRUNCATE TABLE 等很多 DDL 操作会导致隐式提交,不能认为所有 SQL 都能通过普通事务回滚。


七、事务异常退出会发生什么?

7.1 未提交事务与连接断开

假设当前表为空。

客户端 A 执行:

sql 复制代码
BEGIN;

INSERT INTO account
VALUES (1, '张三', 100.00);

但是没有执行 COMMIT。

此时客户端 A 能够在自己的事务中看到新插入的数据。

如果客户端连接意外断开,MySQL 检测到连接终止后,会回滚该连接尚未提交的事务。

因此,重新连接查询时,刚才的记录不会作为已提交结果保留下来。

7.2 已提交事务与连接断开

如果客户端 A 执行:

sql 复制代码
BEGIN;

INSERT INTO account
VALUES (1, '张三', 100.00);

COMMIT;

然后断开连接,事务已经提交。

再次连接时,通常仍然能查询到该记录。

这里体现了:

  • 未提交事务的修改可以撤销。
  • 已成功提交事务的修改应当持久保存。

但要注意区分:

客户端连接断开 与数据库服务器崩溃不是完全相同的故障场景。

服务器崩溃后的持久性还涉及 Redo Log、刷盘参数及崩溃恢复机制。


八、单条 SQL 与事务的关系

8.1 自动提交模式

例如:

sql 复制代码
SET AUTOCOMMIT = 1;

随后执行:

sql 复制代码
INSERT INTO account
VALUES (2, '李四', 1000.00);

如果语句成功执行,并且当前没有显式开启的事务,那么该操作通常会自动提交。

所以,即使没有手动写:

sql 复制代码
BEGIN;
COMMIT;

InnoDB 仍会使用事务机制管理这个操作。

8.2 关闭自动提交模式

执行:

sql 复制代码
SET AUTOCOMMIT = 0;

再执行:

sql 复制代码
INSERT INTO account
VALUES (3, '王五', 2000.00);

此时修改尚未自动提交。

如果关闭连接而没有 COMMIT,未提交的修改将被回滚。

如果执行:

sql 复制代码
COMMIT;

则将该修改提交。

最后恢复自动提交:

sql 复制代码
SET AUTOCOMMIT = 1;

8.3 事务使用注意事项

需要记住:

  1. 显式开启的事务需要明确提交或回滚。
  2. 已经提交的事务不能直接通过普通 ROLLBACK 撤销。
  3. 连接异常断开时,尚未提交的事务会被回滚。
  4. InnoDB 支持事务,MyISAM 不支持。
  5. 不要在事务中随意执行可能触发隐式提交的 DDL。
  6. 长时间不结束事务可能导致锁等待、版本保留和资源占用。

九、什么是事务隔离性?

假设 MySQL 同时处理两个事务:

text 复制代码
事务 A:修改张三的余额

事务 B:查询张三的余额

事务 A 的执行过程:

text 复制代码
BEGIN
  ↓
UPDATE
  ↓
尚未 COMMIT
  ↓
COMMIT

如果事务 B 在事务 A 提交之前查询,那么它应该看到旧余额还是新余额?

如果事务 B 已经读取过一次余额,之后事务 A 提交了新余额,那么事务 B 再次读取时,应该看到哪个版本?

这些问题都属于事务隔离性。

9.1 多事务并发的三类问题

常见的并发读取异常包括:

  • 脏读(Dirty Read)。
  • 不可重复读(Non-repeatable Read)。
  • 幻读(Phantom Read)。

下面通过两个数据库连接进行实验。

9.2 准备两个客户端

在 VS Code 中打开两个远程终端。

分别连接 MySQL:

bash 复制代码
mycli -h 127.0.0.1 -P 3306 -u root -D lab09

约定:

text 复制代码
终端 A → 事务 A
终端 B → 事务 B

两个终端必须是两个独立的 MySQL 连接。

可以分别执行:

sql 复制代码
SELECT CONNECTION_ID();

确认连接编号不同。

另外,为了避免之前实验的数据影响结果,可以新建一张并发实验表:

sql 复制代码
CREATE TABLE isolation_demo (
    id INT PRIMARY KEY,
    name VARCHAR(20),
    balance DECIMAL(10,2)
) ENGINE=InnoDB;

插入初始记录:

sql 复制代码
INSERT INTO isolation_demo
VALUES (1, '张三', 100.00);

后面的每个实验,都以这条记录的余额 100.00 为初始状态。

各实验结束后,先确保两个连接没有未结束的事务,再恢复初始余额。


十、四种事务隔离级别

MySQL 5.7 的 InnoDB 支持四种隔离级别。

隔离级别 中文名称 主要特点
READ UNCOMMITTED 读未提交 允许读取其他事务未提交的修改
READ COMMITTED 读已提交 普通查询只能看到其他事务已提交的修改
REPEATABLE READ 可重复读 普通一致性读通常复用同一快照
SERIALIZABLE 串行化 通过更严格的锁定规则限制并发冲突

图 2:四种隔离级别比较图。来源:阿里云开发者社区。

10.1 查看当前隔离级别

MySQL 5.7 可以使用:

sql 复制代码
SELECT @@session.tx_isolation;

查看当前会话隔离级别。

也可以:

sql 复制代码
SELECT @@global.tx_isolation;

查看全局默认设置。

默认通常是:

text 复制代码
REPEATABLE-READ

其中:

  • session:当前连接。
  • global:服务器全局默认设置。

10.2 修改当前会话的隔离级别

例如:

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

表示将当前会话的隔离级别设置为读已提交。

这只影响当前会话中后续适用的事务,不会直接修改其他已连接客户端的隔离级别。

建议在没有活动事务时设置,避免与当前事务状态冲突。

10.3 为什么不直接修改全局隔离级别?

MySQL 还支持:

sql 复制代码
SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;

但这会影响之后新建立连接所继承的默认事务隔离级别。

在学习阶段,为了避免影响其他程序连接,建议优先使用 SET SESSION。


十一、读未提交(READ UNCOMMITTED)

11.1 什么是脏读?

脏读是指:

一个事务读取了另一个事务尚未提交的修改。

如果那个事务后来回滚,之前读取到的数据就属于没有最终生效的数据。

图 3:脏读示意图。来源:博客园《一文详解脏读、不可重复读、幻读》。

11.2 实验步骤

首先确保余额为:

text 复制代码
100.00

在两个终端中分别执行:

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

终端 A:

sql 复制代码
BEGIN;

UPDATE isolation_demo
SET balance = 200.00
WHERE id = 1;

注意:这里暂时不要 COMMIT。

终端 B:

sql 复制代码
BEGIN;

SELECT balance
FROM isolation_demo
WHERE id = 1;

在 READ UNCOMMITTED 下,B 可以读到:

text 复制代码
200.00

但实际上 A 还没有提交。

切换回终端 A:

sql 复制代码
ROLLBACK;

事务 A 的修改被撤销。

回到终端 B:

sql 复制代码
SELECT balance
FROM isolation_demo
WHERE id = 1;

此时可以再次读到:

text 复制代码
100.00

最后:

sql 复制代码
ROLLBACK;

结束 B 的事务。

11.3 为什么脏读危险?

假设 B 根据读取到的 200.00 余额,执行了某项业务操作。

但随后 A 回滚,真实余额恢复成 100.00。

那么 B 就依据一份没有最终生效的数据进行了业务处理。

这可能导致错误判断。

因此,READ UNCOMMITTED 通常不适合要求数据可靠性的核心业务。


十二、读已提交(READ COMMITTED)

12.1 什么是读已提交?

读已提交表示:

事务不能读取其他事务尚未提交的修改。

但是在同一个事务中,多次读取同一条记录,仍可能得到不同结果。

这种现象叫做不可重复读。

12.2 什么是不可重复读?

假设:

text 复制代码
事务 B 第一次读取:balance = 100

事务 A 修改 balance = 200 并提交

事务 B 第二次读取:balance = 200

B 始终没有提交自己的事务,但两次查询得到的值发生了变化。

这就是不可重复读。

图 4:不可重复读示意图。来源:小林coding《事务隔离级别是怎么实现的?》。

12.3 实验步骤

确保初始余额为:

text 复制代码
100.00

两个终端分别执行:

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

终端 B:

sql 复制代码
BEGIN;

SELECT balance
FROM isolation_demo
WHERE id = 1;

此时返回:

text 复制代码
100.00

终端 A:

sql 复制代码
BEGIN;

UPDATE isolation_demo
SET balance = 200.00
WHERE id = 1;

暂时不要提交。

终端 B:

sql 复制代码
SELECT balance
FROM isolation_demo
WHERE id = 1;

仍然看到:

text 复制代码
100.00

因为 A 的修改尚未提交。

终端 A:

sql 复制代码
COMMIT;

终端 B:

sql 复制代码
SELECT balance
FROM isolation_demo
WHERE id = 1;

现在结果变为:

text 复制代码
200.00

说明:

读已提交能够避免脏读,但仍可能发生不可重复读。

最后:

sql 复制代码
COMMIT;

结束 B 的事务。


十三、可重复读(REPEATABLE READ)

13.1 什么是可重复读?

可重复读是 MySQL 5.7 InnoDB 的默认事务隔离级别。

对于普通 SELECT 形成的一致性读,它通常使用同一个事务内首次一致性读建立的快照。

因此,在同一个事务中:

text 复制代码
第一次 SELECT
第二次 SELECT
第三次 SELECT

即使其他事务中途提交修改,当前事务仍可以继续读取先前快照中的版本。

13.2 实验步骤

先恢复初始余额:

sql 复制代码
UPDATE isolation_demo
SET balance = 100.00
WHERE id = 1;

两个终端分别设置:

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

终端 B:

sql 复制代码
BEGIN;

SELECT balance
FROM isolation_demo
WHERE id = 1;

结果:

text 复制代码
100.00

这次普通 SELECT 建立了一致性读快照。

终端 A:

sql 复制代码
BEGIN;

UPDATE isolation_demo
SET balance = 300.00
WHERE id = 1;

COMMIT;

此时 A 已经将余额修改为 300.00。

终端 B:

sql 复制代码
SELECT balance
FROM isolation_demo
WHERE id = 1;

结果仍然是:

text 复制代码
100.00

因为 B 继续使用此前建立的读视图。

然后 B 执行:

sql 复制代码
COMMIT;

再查询:

sql 复制代码
SELECT balance
FROM isolation_demo
WHERE id = 1;

此时能够看到:

text 复制代码
300.00

这说明 MySQL 在可重复读隔离级别下,能够为普通一致性读提供稳定的可见性。

13.3 一个重要问题:BEGIN 就创建快照了吗?

不一定。

在 MySQL 5.7 InnoDB 的普通 REPEATABLE READ 事务中:

sql 复制代码
BEGIN;

本身通常不会立即建立后续普通 SELECT 使用的一致性读快照。

通常第一次一致性读才建立对应 Read View。

如果希望在事务开始时建立一致性快照,可以使用:

sql 复制代码
START TRANSACTION WITH CONSISTENT SNAPSHOT;

这一点将在下篇 MVCC 原理中进一步解释。


十四、什么是幻读(Phantom Read)?

14.1 幻读的基本概念

幻读主要指:

同一事务使用相同的条件重复查询时,由于其他事务的插入、删除等操作,发现符合条件的记录集合发生变化。

例如:

第一次查询:

sql 复制代码
SELECT *
FROM isolation_demo
WHERE balance >= 500;

得到两条记录。

另一个事务插入了一条余额为 600 的记录并提交。

再次使用相同条件查询,得到三条记录。

这类新增或消失的匹配记录,就是典型幻读现象。

14.2 READ COMMITTED 下的幻读实验

先准备数据:

sql 复制代码
INSERT INTO isolation_demo
VALUES (2, '李四', 600.00);

两个终端分别设置:

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

终端 B:

sql 复制代码
BEGIN;

SELECT id, name, balance
FROM isolation_demo
WHERE balance >= 500
ORDER BY id;

当前可以查询到李四。

终端 A:

sql 复制代码
BEGIN;

INSERT INTO isolation_demo
VALUES (3, '王五', 700.00);

COMMIT;

终端 B:

sql 复制代码
SELECT id, name, balance
FROM isolation_demo
WHERE balance >= 500
ORDER BY id;

这次能够查询到李四和王五。

因此,查询结果从一条变成了两条。

最后:

sql 复制代码
COMMIT;

14.3 MySQL 的可重复读能否避免幻读?

这个问题需要分情况讨论。

第一种:普通 SELECT 快照读。

在 InnoDB 的 REPEATABLE READ 下,普通 SELECT 通常复用同一个 Read View。

因此,其他事务在快照建立之后插入的新记录,不会自动出现在后续使用同一个快照的查询中。

这能够避免典型的快照读幻读现象。

第二种:当前读。

例如:

sql 复制代码
SELECT *
FROM isolation_demo
WHERE balance >= 500
FOR UPDATE;

这种查询需要读取用于加锁的当前记录状态。

InnoDB 可以通过记录锁、间隙锁和 Next-Key Lock 等机制控制范围内的并发插入。

但不能简单认为所有当前读在所有操作组合下都绝对不会出现任何类似幻读的现象。

尤其当同一事务混用快照读、当前读或进行自己的数据修改时,需要具体分析可见性。

所以,更准确的结论是:

InnoDB 在 REPEATABLE READ 下,通过 MVCC 和锁机制,在大量常见场景中避免幻读。


十五、串行化(SERIALIZABLE)

15.1 什么是串行化?

SERIALIZABLE 是四种隔离级别中约束最严格的一种。

它会通过更严格的锁定规则,让存在冲突的读写操作相互等待,从而降低并发执行时的异常风险。

但是需要注意:

串行化不等于所有事务在任何情况下都完全不能并发。

例如,两个兼容的读操作仍然可能并发执行。

关键是发生冲突的操作受到更严格的限制。

15.2 设置隔离级别

sql 复制代码
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;

查看:

sql 复制代码
SELECT @@session.tx_isolation;

应该返回:

text 复制代码
SERIALIZABLE

15.3 简单并发实验

确保没有其他未完成事务。

终端 A:

sql 复制代码
BEGIN;

SELECT *
FROM isolation_demo
WHERE id = 1;

在该隔离级别下,显式事务中的普通 SELECT 通常会按照锁定读的规则获取共享锁。

终端 B:

sql 复制代码
BEGIN;

UPDATE isolation_demo
SET balance = 999
WHERE id = 1;

由于 A 持有相关读取锁,B 的 UPDATE 可能进入锁等待状态。

此时:

终端 A:

sql 复制代码
COMMIT;

释放相关事务锁。

B 就有机会继续执行。

终端 B:

sql 复制代码
ROLLBACK;

撤销本次实验更新。

注意,锁等待也可能因为超时、死锁处理或其他并发行为而提前结束,因此具体结果需要结合实际环境观察。

15.4 串行化的优缺点

优点:

  • 提供严格的隔离语义。
  • 可以避免更多并发异常。

缺点:

  • 锁等待可能增加。
  • 并发吞吐量可能降低。
  • 复杂事务可能产生更高的锁竞争成本。

因此,是否选择 SERIALIZABLE,需要根据实际业务一致性要求和并发特征决定。


十六、四种隔离级别总结

隔离级别 脏读 不可重复读 幻读
READ UNCOMMITTED 可能 可能 可能
READ COMMITTED 避免 可能 可能
REPEATABLE READ 避免 避免 SQL 标准允许;InnoDB 有额外防护
SERIALIZABLE 避免 避免 避免

表格给出了隔离语义的主要区别。

需要注意:

  • 表格中的 RR 幻读说明,是为了区分 SQL 标准语义和 InnoDB 的具体实现。
  • InnoDB 的一致性读通过 MVCC 实现。
  • 锁定读及 UPDATE、DELETE 的行为还涉及记录锁和范围锁。
  • 提高隔离级别不一定导致所有查询都更慢,但通常可能带来更严格的并发约束。

16.1 三种并发读取问题的区别

脏读:

读到了其他事务未提交的数据。

不可重复读:

同一事务前后读取同一数据,发现已提交的值发生变化。

幻读:

同一事务前后按照相同条件查询,发现匹配的记录集合发生变化。

可以简化记忆:

text 复制代码
脏读:读取未提交的数据

不可重复读:已读取记录的值发生变化

幻读:符合条件的记录集合发生变化

不过这只是帮助初学者记忆的概括,实际分析仍需要结合事务操作和读取方式。


十七、事务的一致性与业务逻辑

回到最开始的银行转账案例。

事务可以保证:

sql 复制代码
BEGIN;

UPDATE account
SET balance = balance - 100
WHERE id = 1;

UPDATE account
SET balance = balance + 100
WHERE id = 2;

COMMIT;

这两条更新可以整体提交或回滚。

但是,如果张三的余额原本只有 50 元,直接减去 100 元就可能得到负数。

事务本身并不知道:

text 复制代码
账户余额不能为负数

这是一条业务规则。

因此,应用程序必须额外检查。

例如:

sql 复制代码
UPDATE account
SET balance = balance - 100
WHERE id = 1
  AND balance >= 100;

只有余额足够时才允许扣款。

应用程序还需要检查该 SQL 实际影响的行数,并根据结果决定是否执行后续操作。

这说明:

事务是维护业务一致性的重要技术基础,但不等于自动完成全部业务正确性校验。


十八、常见问题总结

18.1 BEGIN 和 START TRANSACTION 有什么区别?

在这里,它们都可以显式开启事务:

sql 复制代码
BEGIN;
sql 复制代码
START TRANSACTION;

START TRANSACTION 支持更多事务特性选项,例如 WITH CONSISTENT SNAPSHOT。

18.2 BEGIN 之后 autocommit 会自动变成 OFF 吗?

不一定。

BEGIN 会显式开始事务,但不会永久修改会话的 autocommit 系统变量。

即使 autocommit=ON,显式事务也需要 COMMIT 或 ROLLBACK 结束。

18.3 SAVEPOINT 是否等于提交?

不是。

SAVEPOINT 只是事务内部的保存点,不会将事务提交。

18.4 COMMIT 之后还能 ROLLBACK 吗?

不能通过普通 ROLLBACK 撤销已经成功提交的事务。

如果需要撤销业务效果,通常应执行新的补偿事务。

18.5 事务能够包含 CREATE TABLE 吗?

可以在事务会话中执行 DDL,但许多 DDL 会导致隐式提交。

因此,不应认为 CREATE TABLE 等操作都能与普通 DML 一起被完整回滚。

18.6 为什么需要两个 MySQL 连接实验?

因为隔离性涉及不同事务之间的数据可见性。

只有一个连接时,很难观察另一个事务未提交或已经提交的修改对当前事务的影响。

18.7 MySQL 默认隔离级别是什么?

MySQL 5.7 InnoDB 默认是:

text 复制代码
REPEATABLE READ

也就是可重复读。


十九、常用事务 SQL 命令速查

指令 作用
BEGIN 显式开启事务
START TRANSACTION 显式开启事务
COMMIT 提交事务
ROLLBACK 回滚当前事务
SAVEPOINT name 创建保存点
ROLLBACK TO SAVEPOINT name 回滚到保存点
RELEASE SAVEPOINT name 删除保存点
SET AUTOCOMMIT=0 关闭自动提交
SET AUTOCOMMIT=1 开启自动提交
SHOW VARIABLES LIKE 'autocommit' 查看提交模式
SELECT @@session.tx_isolation 查看当前会话隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL ... 设置当前会话隔离级别

二十、总结

本篇主要学习了 MySQL 事务的基础知识。

首先理解了事务的核心目标:

让多条相关 SQL 作为一个整体工作,并对并发访问提供指定的隔离规则。

接着学习了 ACID 四大特性:

  • 原子性:事务修改整体提交或撤销。
  • 一致性:事务前后遵守数据约束和业务规则。
  • 隔离性:控制并发事务之间的可见性与相互影响。
  • 持久性:已提交事务的结果能够持久保存。

然后掌握了:

sql 复制代码
BEGIN;
COMMIT;
ROLLBACK;
SAVEPOINT;

等常用事务控制指令。

最后,通过两个 MySQL 连接完成了事务隔离级别实验,理解了:

  • 脏读。
  • 不可重复读。
  • 幻读。
  • 四种事务隔离级别的区别。

但还有一个重要问题:

在 MySQL 的可重复读隔离级别下,为什么一个事务能够反复读取同一份数据,而另一个事务仍然可以修改并提交?

这需要进一步理解 InnoDB 的多版本并发控制机制。

相关推荐
蒸蒸yyyyzwd8 分钟前
秋招操作系统错题本
笔记·八股
草莓熊Lotso31 分钟前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
IT大白鼠39 分钟前
eBPF 观测入门:用 bpftrace 给服务器装上“内核摄像头“
运维·服务器·ebpf
星恒随风44 分钟前
MySQL 从零入门(十一):视图与用户权限管理详解
linux·服务器·数据库·笔记·mysql
天翼云开发者社区1 小时前
天翼云TeleDB最佳实践:某大型企业平滑去O,国产化替代一步到位
数据库
青山不见1 小时前
告别手动拼参数!IDEA 插件 Log2SQL:MyBatis/Hibernate 日志秒变可执行 SQL
数据库
山楂树の1 小时前
Java 泛型:泛型类、泛型方法、泛型接口与通配符
java·开发语言·笔记
李兆龙的博客1 小时前
从一到无穷大 #115:企业级 SSD 涨价后的容量利用率与磨损管理
数据库·ssd·nvme