MySQL 事务简介

掌勺者2026-03-31 8:21

简介

MySQL 事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务：

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

  • 事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。

  • 事务用来管理 insert,update,delete 语句

事务的满足条件

一般来说，事务是必须满足4个条件（ACID）：原子性（A tomicity，或称不可分割性）、一致性（C onsistency）、隔离性（I solation，又称独立性）、持久性（Durability）。

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

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

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

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

【注意】在 MySQL 命令行的默认设置下，事务都是自动提交的，即执行 SQL 语句后就会马上执行 COMMIT 操作。因此要显式地开启一个事务务须使用命令 BEGIN 或 START TRANSACTION，或者执行命令 SET AUTOCOMMIT=0，用来禁止使用当前会话的自动提交。

事务控制语句

  • BEGIN或START TRANSACTION：显式地开启一个事务。

  • COMMIT：也可以使用COMMIT WORK，不过二者是等价的。COMMIT会提交事务，并使已对数据库进行的所有修改称为永久性的。

  • ROLLBACK：也可以使用ROLLBACK WORK，不过二者是等价的。回滚会结束用户的事务，并撤销正在进行的所有未提交的修改。

  • SAVEPOINT identifier：SAVEPOINT允许在事务中创建一个保存点，一个事务中可以有多个SAVEPOINT。

  • RELEASE SAVEPOINT identifier：删除一个事务的保存点，当没有指定的保存点时，执行该语句会抛出一个异常。

  • ROLLBACK TO identifier：把事务回滚到标记点。

  • SET TRANSACTION：用来设置事务的隔离级别。InnoDB存储引擎提供事务的隔离级别有READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ和SERIALIZABLE。

事务处理方法

1.用 BEGIN, ROLLBACK, COMMIT来实现

  • BEGIN 开始一个事务

  • ROLLBACK 事务回滚

  • COMMIT 事务确认

2.直接用 SET 来改变 MySQL 的自动提交模式:

  • SET AUTOCOMMIT=0 禁止自动提交

  • SET AUTOCOMMIT=1 开启自动提交

事务使用例子

复制代码

mysql> use RUNOOB;

Database changed

mysql> CREATE TABLE runoob_transaction_test( id int(5)) engine=innodb; # 创建数据表

Query OK, 0 rows affected (0.04 sec)

mysql> select * from runoob_transaction_test;

Empty set (0.01 sec)

mysql> begin; # 开始事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into runoob_transaction_test value(5);

Query OK, 1 rows affected (0.01 sec)

mysql> insert into runoob_transaction_test value(6);

Query OK, 1 rows affected (0.00 sec)

mysql> commit; # 提交事务

Query OK, 0 rows affected (0.01 sec)

mysql> select * from runoob_transaction_test;

+------+

| id |

+------+

| 5 |

| 6 |

+------+

2 rows in set (0.01 sec)

mysql> begin; # 开始事务

Query OK, 0 rows affected (0.00 sec)

mysql> insert into runoob_transaction_test values(7);

Query OK, 1 rows affected (0.00 sec)

mysql> rollback; # 回滚

Query OK, 0 rows affected (0.00 sec)

mysql> select * from runoob_transaction_test; # 因为回滚所以数据没有插入

+------+

| id |

+------+

| 5 |

| 6 |

+------+

2 rows in set (0.01 sec)

mysql>

php使用事务例子

复制代码

<?php

$dbhost = 'localhost:3306'; // mysql服务器主机地址

$dbuser = 'root'; // mysql用户名

$dbpass = '123456'; // mysql用户名密码

conn = mysqli_connect(dbhost, dbuser, dbpass);

if(! $conn )

{

die('连接失败: ' . mysqli_error($conn));

}

// 设置编码，防止中文乱码

mysqli_query($conn, "set names utf8");

mysqli_select_db( $conn, 'RUNOOB' );

mysqli_query($conn, "SET AUTOCOMMIT=0"); // 设置为不自动提交，因为MYSQL默认立即执行

mysqli_begin_transaction($conn); // 开始事务定义

if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(8)"))

{

mysqli_query($conn, "ROLLBACK"); // 判断当执行失败时回滚

}

if(!mysqli_query($conn, "insert into runoob_transaction_test (id) values(9)"))

{

mysqli_query($conn, "ROLLBACK"); // 判断执行失败时回滚

}

mysqli_commit($conn); //执行事务

mysqli_close($conn);

?>

事务的并发问题

脏读：

事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据

不可重复读：

事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果 不一致。

幻读：

系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。

【注意】不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表。针对可能的问题，InnoDB提供了四种不同级别的机制保证数据隔离性。 事务的隔离用是通过锁机制实现的，不同于MyISAM使用表级别的锁，InnoDB采用更细粒度的行级别锁，提高了数据表的性能。InnoDB的锁通过锁定索引来实现，如果查询条件中有主键则锁定主键，如果有索引则先锁定对应索引然后再锁定对应的主键（可能造成死锁），如果连索引都没有则会锁定整个数据表。

事务隔离级别

读未提交（read-uncommitted）

READ UNCOMMIT允许某个事务看到其他事务并没有提交的数据。可能会导致脏读、不可重复读、幻影数据。

原理：READ UNCOMMIT不会采用任何锁。

不可重复读（read-committed）

READ COMMIT允许某个事务看到其他事务已经提交的数据。可能会导致不可重复读和幻影数据。

原理：数据的读是不加锁的，但是数据的写入、修改、删除加锁，避免了脏读。

可重复读（repeatable-read）

InnoDB中REPEATABLE READ级别同一个事务的两次相同读取肯定是一样的，其他事务的提交不会对本次事务有影响。可能会导致幻影数据。

原理：数据的读、写都会加锁，当前事务如果占据了锁，其他事务必须等待本次事务提交完成释放锁后才能对相同的数据行进行操作。

串行化（serializable）

避免了脏读、不可重复读和幻读

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

【注意】mysql默认的事务隔离级别为repeatable-read

事务隔离具体例子

读未提交

1.打开一个客户端A，并设置当前事务模式为read uncommitted（未提交读），查询表account的初始值：

2.在客户端A的事务提交之前，打开另一个客户端B，更新表account：

3.这时，虽然客户端B的事务还没提交，但是客户端A就可以查询到B已经更新的数据：

4.一旦客户端B的事务因为某种原因回滚，所有的操作都将会被撤销，那客户端A查询到的数据其实就是脏数据：

5.在客户端A执行更新语句update account set balance = balance - 50 where id =1，lilei的balance没有变成350，居然是400，是不是很奇怪，数据不一致啊，如果你这么想就太天真 了，在应用程序中，我们会用400-50=350，并不知道其他会话回滚了，要想解决这个问题可以采用读已提交的隔离级别

读已提交

1.打开一个客户端A，并设置当前事务模式为read committed（未提交读），查询表account的初始值：

2.在客户端A的事务提交之前，打开另一个客户端B，更新表account：

3.这时，客户端B的事务还没提交，客户端A不能查询到B已经更新的数据，解决了脏读问题：

4.客户端B的事务提交

5.客户端A执行与上一步相同的查询，结果 与上一步不一致，即产生了不可重复读的问题

可重复读

1.打开一个客户端A，并设置当前事务模式为repeatable read，查询表account

2.在客户端A的事务提交之前，打开另一个客户端B，更新表account并提交

3.在客户端A执行步骤（1）的查询：

4.执行步骤（1），lilei的balance仍然是400与步骤（1）查询结果一致，没有出现不可重复读的 问题；接着执行update balance = balance - 50 where id = 1，balance没有变成400-50=350，lilei的balance值用的是步骤（2）中的350来算的，所以是300，数据的一致性倒是没有被破坏，这个有点神奇，也许是mysql的特色吧

复制代码

mysql> select * from account;

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

| id | name | balance |

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

| 1 | lilei | 400 |

| 2 | hanmei | 16000 |

| 3 | lucy | 2400 |

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

3 rows in set (0.00 sec)

mysql> update account set balance = balance - 50 where id = 1;

Query OK, 1 row affected (0.00 sec) Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from account;

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

| id | name | balance |

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

| 1 | lilei | 300 |

| 2 | hanmei | 16000 |

| 3 | lucy | 2400 |

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

3 rows in set (0.00 sec)

5.在客户端A提交事务，查询表account的初始值

复制代码

mysql> commit;

Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;

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

| id | name | balance |

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

| 1 | lilei | 300 |

| 2 | hanmei | 16000 |

| 3 | lucy | 2400 |

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

3 rows in set (0.00 sec)

6.在客户端B开启事务，新增一条数据，其中balance字段值为600，并提交

复制代码

mysql> start transaction;

Query OK, 0 rows affected (0.00 sec)

mysql> insert into account values(4,'lily',600);

Query OK, 1 row affected (0.00 sec)

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

7.在客户端A计算balance之和，值为300+16000+2400=18700，没有把客户端B的值算进去，客户端A提交后再计算balance之和，居然变成了19300，这是因为把客户端B的600算进去了。

站在客户的角度，客户是看不到客户端B的，它会觉得是天下掉馅饼了，多了600块，这就是幻读。

站在开发者的角度，数据的一致性并没有破坏。

但是在应用程序中，我们得代码可能会把18700提交给用户了，如果你一定要避免这情况小概率状况的发生，那么就要采取下面要介绍的事务隔离级别"串行化"

复制代码

mysql> select sum(balance) from account;

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

| sum(balance) |

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

| 18700 |

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

1 row in set (0.00 sec)

mysql> commit;

Query OK, 0 rows affected (0.00 sec)

mysql> select sum(balance) from account;

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

| sum(balance) |

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

| 19300 |

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

1 row in set (0.00 sec)

串行化

1.打开一个客户端A，并设置当前事务模式为serializable，查询表account的初始值：

复制代码

mysql> set session transaction isolation level serializable;

Query OK, 0 rows affected (0.00 sec)

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

mysql> select * from account;

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

| id | name | balance |

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

| 1 | lilei | 10000 |

| 2 | hanmei | 10000 |

| 3 | lucy | 10000 |

| 4 | lily | 10000 |

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

4 rows in set (0.00 sec)

2.打开一个客户端B，并设置当前事务模式为serializable，插入一条记录报错，表被锁了插入失败，mysql中事务隔离级别为serializable时会锁表，因此不会出现幻读的情况，这种隔离级别并发性极低，开发中很少会用到。

复制代码

mysql> set session transaction isolation level serializable;

Query OK, 0 rows affected (0.00 sec)

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

mysql> insert into account values(5,'tom',0);

ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

原子性、稳定性和持久性实现原理

原子性、稳定性和持久性是通过redo 和 undo 日志文件实现的，不管是redo还是undo文件都会有一个缓存我们称之为redo_buf和undo_buf。同样，数据库文件也会有缓存称之为data_buf。

undo 日志文件

undo记录了数据在事务开始之前的值，当事务执行失败或者ROLLBACK时可以通过undo记录的值来恢复数据。例如 AA和BB的初始值分别为3，5。

A 事务开始

B 记录AA=3到undo_buf

C 修改AA=1

D 记录BB=5到undo_buf

E 修改BB=7

F 将undo_buf写到undo(磁盘)

G 将data_buf写到datafile(磁盘)

H 事务提交

通过undo可以保证原子性、稳定性和持久性：

  • 如果事务在F之前崩溃由于数据还没写入磁盘，所以数据不会被破坏。

  • 如果事务在G之前崩溃或者回滚则可以根据undo恢复到初始状态。

  • 数据在任务提交之前写到磁盘保证了持久性。

但是单纯使用undo保证原子性和持久性需要在事务提交之前将数据写到磁盘，浪费大量I/O。

redo/undo 日志文件

引入redo日志记录数据修改后的值，可以避免数据在事务提交之前必须写入到磁盘的需求，减少I/O。

A 事务开始

B 记录AA=3到undo_buf

C 修改AA=1 记录redo_buf

D 记录BB=5到undo_buf

E 修改BB=7 记录redo_buf

F 将redo_buf写到redo（磁盘）

G 事务提交

通过undo保证事务的原子性，redo保证持久性：

  • F之前崩溃由于所有数据都在内存，恢复后重新从磁盘载入之前的数据，数据没有被破坏。

  • F和G之间的崩溃可以使用redo来恢复。

  • G之前的回滚都可以使用undo来完成。

相关推荐
小码吃趴菜2 小时前
服务器预约系统linux小项目-第四节课
数据库·sql·mysql
探索宇宙真理.2 小时前
Grafana SQL表达式漏洞 | CVE-2026-27876概念复现&研究
数据库·sql·grafana
Roc-xb2 小时前
Windows MySQL 密码忘记了如何重置密码？
windows·mysql
七七powerful2 小时前
MySQL 8.0 性能优化利器：Percona Toolkit 实战指南
数据库·mysql·性能优化
成为大佬先秃头11 小时前
数据库连接池：Druid
数据库·mysql·druid
晓华-warm14 小时前
Warm-Flow 1.8.5 正式发布：超时自动审批、暂存功能来了！
数据库
u01368638215 小时前
将Python Web应用部署到服务器（Docker + Nginx）
jvm·数据库·python
light blue bird15 小时前
多页签Razor组支轴业务整顿组件
数据库·.net·ai大数据·多功能图表报表·web mvc + razor
wregjru15 小时前
【mysql】2.数据表操作
数据库·mysql
热门推荐
012026年3月AI领域大事件：DeepSeek引领开源风暴02GitHub 镜像站点03围棋-html版本04纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！05班级宠物园部署指南06OpenClaw 使用和管理 MCP 完全指南07“wsl --install -d Ubuntu-22.04”下载慢，中国地区离线安装 Ubuntu 22.04 WSL方法（亲测2025年5月6日）08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09Mac 本地部署 OMLX + 通义千问 Qwen3.5-27B 保姆级教程10中国象棋-html版本