大促当天,一款库存 10 件的商品卖出了 13 件。代码逻辑是「先查库存,够就更新」。两个请求同时进来,都查到库存 10,都判断够,然后都更新成 9,最后超卖,而且库存数还是 9。这不是代码写错,是「读」和「写」之间没有原子性。

另一个更隐蔽的案例:开发明明写了 BEGIN、ROLLBACK,测试也通过,上线后回滚却没生效。查了半天发现建表语句没写 ENGINE=InnoDB,环境默认引擎是 MyISAM——它根本不支持事务。这篇就把事务的边界讲清楚,包括这种「以为有、其实没有」的情况。

场景走查:三件事要么全成,要么全不成

下单要同时做三件事:扣库存、写订单、记流水。如果扣完库存、写订单失败,库存就白扣了;如果订单写了、流水没写,对账就对不上。事务要保证这三步是一个整体。

START TRANSACTION;

UPDATE stock
SET qty = qty - 2
WHERE id = 101 AND qty >= 2;

-- 受影响行数为 0 说明库存不足,业务上要回滚
INSERT INTO orders (customer_id, amount) VALUES (7, 258.00);

INSERT INTO payments (order_id, paid_amount) VALUES (LAST_INSERT_ID(), 258.00);

COMMIT;

关键在 WHERE id = 101 AND qty >= 2:库存判断和扣减是同一条语句,数据库在执行时天然加锁,不存在「查的时候够、写的时候不够」的窗口。实测库存 10、想扣 20 时,受影响行数是 0,剩余库存仍是 10——没有扣成负数。

一个事务的生命周期
BEGIN 开启
多条语句执行
全部成功 COMMIT
任一失败 ROLLBACK

BEGIN、COMMIT、ROLLBACK

MySQL 默认 autocommit = 1,每条语句自己就是一个事务,执行完立即提交。要跨多条语句,显式开启:

BEGIN;
UPDATE orders SET amount = amount + 100 WHERE id = 1;
SELECT amount FROM orders WHERE id = 1;   -- 110.00
ROLLBACK;
SELECT amount FROM orders WHERE id = 1;   -- 10.00

实测在 InnoDB 表上,事务内读到 110,回滚后回到 10。如果表是 MyISAM,回滚后仍然是 110——因为 MyISAM 只支持表级锁,不支持事务和崩溃恢复。我在本机 phpstudy 环境里删掉 ENGINE=InnoDB 重建表,确认了这个行为。

建表一定显式写 ENGINE=InnoDB。用 SHOW TABLE STATUS LIKE 'orders' 或 SHOW CREATE TABLE 确认引擎。默认引擎可能是 MyISAM 的环境并不少见,尤其是老版本或某些集成环境。

还要注意 autocommit 被关掉的情况。有些框架或老代码会执行 SET autocommit = 0,之后每条语句都不再自动提交,必须手动 COMMIT。连接还回连接池时若没有提交,这条未结束的事务会挂在连接上,下一个请求拿到同一条连接,可能接着这个事务继续写,甚至把上一个请求的半成品一起提交。表现是「数据偶发多了一条」「回滚了却没生效」,换个连接就复现不了,极难排查。检查方法是看连接池配置有没有统一 autocommit,以及归还连接前有没有显式提交或回滚。

异常处理的位置也会让回滚「静默失效」。不少框架的事务拦截器默认只对运行时异常回滚,检查型异常不回滚;如果代码把异常吞掉、包装成另一种类型再抛,事务可能已经提交。排查「为什么没回滚」时,除了看引擎和 DDL,也要看回滚规则配的是哪些异常类型。

ACID 逐条说人话

原子性(Atomicity):一个事务里的操作要么全做,要么全不做,靠 undo log 回滚
一致性(Consistency):事务前后数据满足业务规则,靠约束和业务逻辑共同保证
隔离性(Isolation):并发事务之间不互相干扰,靠锁和 MVCC 实现
持久性(Durability):提交后的数据不丢,靠 redo log 刷盘

四个词里,最容易被误解的是「一致性」。数据库能保证的是「约束不被违反」(唯一、外键、非空),但「转账前后总额不变」这种业务规则,得靠代码和事务边界保证。事务不是魔法,它只保证你写进去的东西整体生效或整体不生效,不保证你写的内容符合业务。

持久性也不等于「每次提交都立刻写磁盘」。InnoDB 写 redo log 并刷盘,数据页可以延迟写回;崩溃后用 redo log 恢复。这个机制叫 WAL(Write-Ahead Logging),先写日志再改数据,兼顾性能和安全。

undo 和 redo 的区别也常被问:undo 记录「怎么撤销」,服务两件事——回滚,以及 MVCC 读取旧版本;redo 记录「改成了什么」,只服务崩溃恢复。两者都写日志,但方向相反:一个负责「当没发生过」,一个负责「发生过就不能丢」。提交时 redo 必须按 innodb_flush_log_at_trx_commit 的配置刷盘,undo 则由后台 purge 慢慢清理,长事务会让它一直清不掉。

丢失更新:读改写为什么危险

回到超卖。两个事务都执行:

-- 事务 A
SELECT qty FROM stock WHERE id = 101;   -- 10
UPDATE stock SET qty = 9 WHERE id = 101;
COMMIT;

-- 事务 B(几乎同时)
SELECT qty FROM stock WHERE id = 101;   -- 也读到 10
UPDATE stock SET qty = 9 WHERE id = 101;
COMMIT;

两次都读到 10,都写成 9。库存只减了 1,却卖出了 2 件。这叫丢失更新。在可重复读隔离级别下,普通 SELECT 读的是快照,不加锁,所以挡不住这种并发。

三种修法各有适用场景:

做法写法适用与代价
条件更新UPDATE ... SET qty = qty - 2 WHERE qty >= 2最简单,靠受影响行数判断成败;适合数值增减
悲观锁SELECT ... FOR UPDATE 再改语义清楚,但持有锁时间长,并发下容易排队
乐观锁UPDATE ... WHERE version = ?,失败重试适合冲突少的场景,冲突多时重试成本高

条件更新是库存、余额这类场景的首选:判断和修改在同一条语句里,不需要显式锁,也不会读到过期快照。乐观锁适合「读出来、算一会、再写回」的业务,比如编辑商品信息,版本号不匹配就提示「数据已变更」。

事务边界:别把网络请求包进去

有段代码在事务里调用了支付网关,等回调等了 3 秒。这 3 秒里,事务一直持有行锁,其他请求全部排队;如果网关超时,事务回滚,但外部支付可能已经成功。更糟的是长事务导致 undo log 膨胀、主从延迟增加。

原则是:事务只包「必须一起成功或失败的数据库写操作」,网络调用、消息发送、文件上传都放到事务外。典型模式是「本地消息表」:事务内写业务数据和消息记录,事务提交后再由后台任务发消息,失败重试。这样数据库一致性和外部调用解耦。

事务也别开得太早。常见写法是 BEGIN 之后先查一堆数据、做校验、拼参数,最后才写。查询阶段完全不需要事务,晚点开能少占锁。

长事务的危害不只是「锁得久」。它会让 undo log 迟迟不能清理,purge 线程落后,历史版本越积越多,磁盘和内存都被占着;在主从架构里,长事务还会拖慢从库回放,表现为复制延迟越来越大。排查时查 information_schema.innodb_trx,看 trx_started 和 trx_rows_modified,再配合 SHOW PROCESSLIST 找到对应连接,确认它卡在哪一步:是在等用户输入、等外部接口,还是在做大批量更新。找到原因再拆事务,别直接粗暴地杀掉连接。

翻车现场:等了 2.68 秒,报 1205

某次下单接口加了「风控校验」,代码写在事务中间:

BEGIN;
UPDATE stock SET qty = qty - 1 WHERE id = 101;
-- 调用风控 HTTP 接口,超时 2 秒
INSERT INTO orders (customer_id, amount) VALUES (7, 99.00);
COMMIT;

风控接口平时 200 ms,那天抖动到 2 秒多。这 2 秒里,id=101 这行库存一直被第一个事务锁着,其他下单请求的 UPDATE stock 全部排队。本机把当前会话的 innodb_lock_wait_timeout 设为 3 秒,用两个会话复现:A 先 BEGIN 并更新同一行后不提交,B 执行更新,2.68 秒后拿到 ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction。

2.68 秒不是精确的 3 秒,因为等待超时的检查是周期性的,实际报错时间会有偏差。但方向很清楚:这个请求不是「算得慢」,它是在等锁。如果接口没有捕获 1205,用户看到的是 500;如果框架自动重试,又会把压力放大。

把风控校验挪到事务外,问题立刻消失:先调接口拿到结果,再开事务做三步写操作,事务只持有毫秒级的锁。如果风控必须在事务内保持一致,那就把超时压到几百毫秒,并接受「校验失败就回滚」的代价,而不是让数据库连接替外部服务背锅。

排查时不要只看应用日志的「请求超时」。在数据库侧查 information_schema.innodb_trx,找到 trx_state='LOCK WAIT' 的记录,trx_wait_started 和 trx_query 会告诉你它在等哪条语句;再顺着 trx_mysql_thread_id 找到持锁的会话,看它是在执行,还是已经闲着却忘了提交。1205 的根因,十次里有八次是「另一个事务忘了结束」。

看到 1205 别急着调大 innodb_lock_wait_timeout。调大只是让请求等更久,锁的持有者没变,积压会越来越严重。先找出谁在持锁、持了多久。

隐式提交:哪些操作会偷偷结束事务

MySQL 里有些语句会隐式提交当前事务,最常见的是 DDL:CREATE TABLE、ALTER TABLE、DROP TABLE,以及 LOCK TABLES、部分管理语句。也就是说:

BEGIN;
UPDATE orders SET remark = 'ddl-test' WHERE id = 2;
CREATE TABLE t_ddl (id INT PRIMARY KEY);
ROLLBACK;
SELECT remark FROM orders WHERE id = 2;   -- 仍是 'ddl-test'

实测回滚没有生效,因为 CREATE TABLE 已经把前面的更新提交了。迁移脚本里「先改数据、再建索引」的顺序要特别小心,别以为整段都在一个事务里。

SAVEPOINT 可以在事务内部打点,回滚到某个保存点而不是整个事务:

BEGIN;
UPDATE stock SET qty = qty - 1 WHERE id = 101;
SAVEPOINT after_stock;
INSERT INTO orders (customer_id, amount) VALUES (7, 99.00);
ROLLBACK TO SAVEPOINT after_stock;   -- 只撤销订单插入
COMMIT;                              -- 库存扣减仍然生效

保存点适合「部分步骤失败但仍想保留前面结果」的场景,但业务语义要清楚,别用它来掩盖逻辑错误。

隔离级别先知道有这回事

SQL 标准有四个隔离级别:读未提交、读已提交、可重复读、串行化。MySQL InnoDB 默认是可重复读(RR),PostgreSQL 默认是读已提交(RC)。级别越高,并发异常越少,但锁和等待越多。

RR 下普通 SELECT 读的是事务开始时的快照,所以同一个事务里两次查询结果一致;UPDATE、SELECT ... FOR UPDATE 读的是最新数据(当前读)。这个「快照读 vs 当前读」的区别,是理解锁和死锁的关键,下一篇专门讲。

拿演示库里的库存行实测一次。会话 A 在 RR 下:

BEGIN;
SELECT qty FROM stock WHERE id = 101;   -- 10(快照读)

-- 此时会话 B:UPDATE stock SET qty = 20 WHERE id = 101; COMMIT;

SELECT qty FROM stock WHERE id = 101;   -- 仍然是 10
UPDATE stock SET qty = qty - 1 WHERE id = 101;
SELECT qty FROM stock WHERE id = 101;   -- 19(当前读,基于最新的 20)

同一个事务里,快照读看到 10,当前读看到 20 再减 1。这不是 bug,是 MVCC 的设计:普通读走 Read View,写和锁读必须看最新值,否则就会覆盖别人刚提交的修改。把会话隔离级别改成 RC 再走一遍,第二次普通读就会直接看到 20——RC 每次读都生成新快照。

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
SELECT qty FROM stock WHERE id = 101;   -- 10
-- 会话 B 更新为 20 并提交
SELECT qty FROM stock WHERE id = 101;   -- 20

这两个数字(RR 的 10 和 10、RC 的 10 和 20)是实测出来的,不是理论推导。它解释了一个常见困惑:为什么「同一个事务里查了两次,值没变」,但「更新之后再查就变了」。判断代码有没有踩到,关键看它拿这份数据做什么——只是展示,快照读没问题;要基于它做判断再写,就必须用当前读或条件更新。

不要为了「性能」随意把隔离级别改成读未提交。读未提交会看到别人没提交的数据,脏读会让业务逻辑彻底失控。要改也应该先理解代价,再在明确场景下改。

这四种异常最容易混,列成表对着看:

异常具体表现哪个级别能挡住
脏读读到别的事务还没提交、后面可能回滚的数据读已提交及以上
不可重复读同一事务里两次读同一行,第二次值变了可重复读及以上
幻读同一范围两次查询,第二次多出或少了几行串行化;MySQL 的 RR 用间隙锁在快照读之外挡住
丢失更新两个事务读同一值再写回,后写的覆盖前写的任何级别都不自动挡,要靠条件更新或锁
读偏斜同一事务里分别读两张表,各自一致但合起来违反约束串行化,或改用锁读

拿一个具体例子走一遍。A 事务把余额从 100 改成 50 但还没提交,B 事务这时读到 50,这就是脏读——如果 A 后面回滚了,B 读到的就是个从未存在过的数。读已提交把这种挡住了:B 只能读到已提交的值,也就是 100。但 B 在自己的事务里再读一次,如果 A 提交了 50,B 第二次就会读到 50,这是不可重复读。可重复读让 B 整个事务都看同一个快照,两次都是 100。

幻读常被误解成「不可重复读的另一种说法」,其实不是。不可重复读是同一行的值变了,幻读是同一条件查出来的行数变了,比如 SELECT COUNT(*) FROM orders WHERE customer_id = 7 第一次 20 行,第二次 21 行,多出来的那行像凭空出现。MySQL 的 RR 对普通快照读不产生幻读,因为读的是同一个 Read View;但对 SELECT ... FOR UPDATE 这类当前读,就要靠间隙锁阻止别人往这个范围里插新行。PostgreSQL 的 RC 默认级别下幻读仍可能出现,要用可重复读才能挡住,两边行为别混着记。

现象对照

现象真实原因第一步查什么
库存扣成负数先查后改,中间没有原子性看更新语句有没有 AND qty >= ?,检查受影响行数
写了 ROLLBACK 却没回滚表引擎是 MyISAM,或语句隐式提交了SHOW TABLE STATUS 看引擎;检查事务里有没有 DDL
转账只成功一半两条更新不在同一事务,或异常没触发回滚看代码的 try/catch 和 COMMIT 位置
并发下余额少了丢失更新,读改写没有加锁或条件复现两个并发请求,看更新是否带版本号/原值条件
接口高峰期大量超时长事务持有锁,或事务里包了网络调用查 information_schema.innodb_trx 里运行时间长的事务
下单接口偶发 1205 锁等待超时事务里包了慢调用,锁被长时间持有查 innodb_trx 的 trx_state 与持锁会话
同一事务两次读,值不一样一次是快照读、一次是当前读,或隔离级别是 RC看语句类型和 @@transaction_isolation
提交成功但宕机后数据丢了引擎不支持持久性,或 innodb_flush_log_at_trx_commit 配置不当确认引擎;查该参数是否为 1(默认)

边界与代价

事务的范围越大,锁持有时间越长,并发能力越差。一个事务里更新 10 万行,其他请求只能等;undo log 也会快速膨胀,影响 purge 和主从延迟。大批量更新应该拆成小批次,每批一个短事务。

事务也不是越短越好。把一次业务拆成多个小事务,能减少锁持有时间,但中间失败会留下半成品,需要补偿逻辑。判断标准是「这组写操作是否必须一起成立」:必须一起成立就放一个事务,能接受中间态、可补偿,就拆开。别为了并发把原子性拆没了。

还要接受一个现实:事务能保证的是「数据库这一侧」的一致性。缓存、搜索索引、消息队列这些外部存储,不在这套机制里。写库成功但缓存删失败、消息发失败,都是常见的「最终不一致」,需要补偿任务和对账,而不是再开一个更大的事务。

PostgreSQL 的事务模型和 MySQL 有差异:默认隔离级别是 RC,DDL 支持事务(ALTER TABLE 可以回滚),没有 MySQL 那种隐式提交。把 MySQL 的经验直接搬过去,可能会对「回滚能不能撤销建表」产生误判。

小结

事务保证一组写操作整体生效或整体不生效;原子性靠 undo,持久性靠 redo,隔离性靠锁和 MVCC,一致性靠约束加业务逻辑。库存、余额这类并发写,优先用条件更新;事务边界要短,别把网络调用包进去;注意 DDL 和 MyISAM 这类「事务静默失效」的坑。

当天可以自己验证的练习:

  1. 在 InnoDB 表上依次执行 BEGIN、UPDATE、ROLLBACK,确认数据回到原值。
  2. 把表改成 MyISAM,重复上一步,观察回滚失效。
  3. 在事务里执行一条 CREATE TABLE 再 ROLLBACK,确认前面的更新没有撤销。
  4. 用条件更新扣库存,传入超过库存的数量,确认受影响行数为 0。
  5. 开两个连接模拟并发读改写,观察丢失更新,再用 FOR UPDATE 或版本号修好。

下一篇讲锁、隔离级别与并发写。事务保证「要么全成要么全不成」,但多个事务同时跑的时候,谁等谁、谁挡住谁,由锁决定。接下来看行锁、间隙锁、MVCC 快照读,以及线上最怕的两个报错:锁等待超时和死锁。