第 10 章:事务与并发
前面九章都在假设"一次只有一个人在改数据"。现实是:下单和扣库存同时发生,两个管理员同时点保存,转账扣了钱但对方没收到。事务就是为这些时刻准备的。
学习目标
- 用一个转账例子说清"没有事务会出什么事"
- 记住 ACID 四条各防的是什么问题
- 会用
BEGIN/COMMIT/ROLLBACK,知道事务边界该画在哪 - 分得清脏读、不可重复读、幻读,知道四种隔离级别各自防到哪一步
- 知道死锁怎么发生、怎么避免,乐观锁和悲观锁各用在哪
10.1 没有事务,钱会凭空消失
假设要实现转账:A 给 B 转 100 元,两步操作——
A的余额减 100;B的余额加 100。
如果第 1 步成功、第 2 步因为网络或进程崩溃失败,A 的钱就没了。数据库里没有任何"把两步当成一步"的机制时,这种半完成状态是必然会发生的事,不是小概率。
事务要做的就一件事:把多条语句绑成一个不可分割的整体——要么全部成功,要么全部撤销,不存在中间态。
BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;中间任何一步出错,执行 ROLLBACK,两条 UPDATE 都不留痕迹。
10.2 ACID:四条各自防什么
| 字母 | 含义 | 防的问题 | 失效的后果 |
|---|---|---|---|
| A 原子性 | 要么全做,要么全不做 | 半完成状态 | 钱扣了没到账 |
| C 一致性 | 事务前后数据满足约束 | 违反业务规则 | 余额为负、订单总额对不上 |
| I 隔离性 | 并发事务互不干扰 | 读到别人的中间状态 | 基于脏数据做决策 |
| D 持久性 | 提交后断电也不丢 | 已确认的操作丢失 | 用户付了钱,订单没了 |
四个里最容易被误解的是一致性。它不是数据库自动保证的,而是"数据库提供 A、I、D 的能力,应用负责把业务规则写对"。比如"余额不能为负"要靠 CHECK 或应用逻辑保证,数据库不会替你想这条规则。
10.3 BEGIN / COMMIT / ROLLBACK
SQLite 里最直接的演示:
sqlite> BEGIN;
sqlite> INSERT INTO books (title, category, price) VALUES ('测试书', '测试', 10);
sqlite> SELECT COUNT(*) FROM books; -- 9,能看到自己刚插的行
sqlite> ROLLBACK;
sqlite> SELECT COUNT(*) FROM books; -- 8,回到事务开始前事务的状态流转
要点:
COMMIT之前,你的改动只对自己可见(隔离性),别的连接读不到;ROLLBACK之后,所有改动消失,包括已经成功执行的那几条;- 连接意外断开时,未提交的事务会自动回滚——这是数据库的兜底,不要依赖它做正常流程。
SQLite 的默认行为
SQLite 默认 autocommit:每条 SQL 自己就是一个事务,执行完立即提交。所以你不写 BEGIN,单条 INSERT 也是原子的。
显式 BEGIN 的意义在于把多条语句合并成一个事务。批量插入 1000 行时,放在一个事务里会比 1000 个独立事务快一个数量级——因为每次提交都要写磁盘日志。
事务边界画在哪
这是应用开发里最容易出错的地方。三条原则:
- 一个业务动作 = 一个事务。"下单"包含扣库存、建订单、写明细,这三步必须在一个事务里;
- 事务要短。不要在事务里调用外部接口、发消息、等用户输入——那会把锁持有几秒甚至几分钟;
- 不要在事务里做重试。失败就回滚,重试放在外层重新开事务。
反例:
with transaction():
order = create_order(...)
requests.post("https://payment.example.com/pay", ...) # ← 网络请求在事务里
update_stock(...)支付接口超时 5 秒,数据库锁就被占了 5 秒,其他下单请求全部排队。正确做法是把外部调用挪到事务外,或者用"状态机 + 补偿"(先建待支付订单,支付回调后再改状态)。
10.4 并发会读到什么:三种异常
事务隔离要防的,是三种"读到不该读的数据":
| 异常 | 场景 | 后果 |
|---|---|---|
| 脏读 | 读到别的事务未提交的修改 | 对方回滚了,你的决策基于空气 |
| 不可重复读 | 同一事务内两次读同一行,结果不同 | 中间被别的事务改了 |
| 幻读 | 同一事务内两次同样条件的查询,行数变了 | 中间有人插入/删除了符合条件的行 |
举例说明不可重复读:
事务 A:SELECT balance FROM accounts WHERE id = 1; -- 100
事务 B:UPDATE accounts SET balance = 50 WHERE id = 1; COMMIT;
事务 A:SELECT balance FROM accounts WHERE id = 1; -- 50,同一个事务里变了A 如果基于第一次读到的 100 做判断(比如"余额足够,可以扣 80"),第二次读却变成 50,逻辑就崩了。
10.5 四种隔离级别
| 级别 | 脏读 | 不可重复读 | 幻读 | 性能 |
|---|---|---|---|---|
| 读未提交(Read Uncommitted) | 可能 | 可能 | 可能 | 最高 |
| 读已提交(Read Committed) | 不会 | 可能 | 可能 | 高 |
| 可重复读(Repeatable Read) | 不会 | 不会 | 可能 | 中 |
| 串行化(Serializable) | 不会 | 不会 | 不会 | 最低 |
隔离级别是用性能换正确性:级别越高,并发度越低。
各数据库的默认值不一样:
| 数据库 | 默认级别 | 备注 |
|---|---|---|
| SQLite | 串行化 | 单写者模型,天然接近串行 |
| PostgreSQL | 读已提交 | 需要更强时显式 SET TRANSACTION ISOLATION LEVEL |
| MySQL InnoDB | 可重复读 | 用 MVCC + 间隙锁,多数场景下也防住了幻读 |
所以"我的事务到底隔离到什么程度",不能凭印象,要查你用的那个库的默认值。这也是第 12 章迁移时要重新确认的项之一。
SQLite 的特殊性
SQLite 是单写者:同一时刻只允许一个连接写库,其他写请求等待(默认 5 秒超时,然后报 database is locked)。
好处是并发问题天然简单——不会有两个事务同时改同一行,也就不会出现"更新丢失"。代价是写入吞吐上不去,这也是它不适合高并发服务端的原因。
启用 WAL 模式后,读和写可以并行(读者读快照,写者写日志):
PRAGMA journal_mode = WAL;WAL 适合"读多写少"的桌面/边缘场景,但不改变"单写者"这个根本限制。
10.6 死锁:互相等对方放手
死锁发生在两个事务各自持有对方需要的锁:
事务 A:UPDATE orders SET ... WHERE id = 1; -- 锁住订单 1
事务 B:UPDATE orders SET ... WHERE id = 2; -- 锁住订单 2
事务 A:UPDATE orders SET ... WHERE id = 2; -- 等 B 释放
事务 B:UPDATE orders SET ... WHERE id = 1; -- 等 A 释放 → 互相等待数据库的检测机制会发现环路,牺牲其中一个事务(回滚并报错),另一个继续。所以死锁不会永远卡住,但会导致随机失败,业务上必须能处理这种失败(重试)。
避免死锁的四条实践
- 固定加锁顺序:所有事务都按
id升序更新,A 和 B 就不会交叉; - 事务尽量短:持锁时间越短,撞上的概率越低;
- 一次批量操作排好序:
UPDATE ... WHERE id IN (...)前先ORDER BY id; - 设置锁等待超时,失败后重试,而不是无限等。
SQLite 不会出现这种死锁(只有一个写者),但会直接报
SQLITE_BUSY。到了 PostgreSQL / MySQL,死锁就是必须处理的问题。
10.7 乐观锁与悲观锁
处理并发修改同一行,有两种思路。
悲观锁:先锁住,别人等着
BEGIN;
SELECT * FROM accounts WHERE id = 1 FOR UPDATE; -- 锁住这一行
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
COMMIT;FOR UPDATE 让其他事务在这一行上等待。适合冲突概率高的场景(抢库存、抢座位)。SQLite 不支持 FOR UPDATE(因为它本身就是串行写),PostgreSQL / MySQL 支持。
乐观锁:先改,提交时校验版本
表里加一列 version:
UPDATE accounts
SET balance = balance - 100, version = version + 1
WHERE id = 1 AND version = 5;
-- 受影响行数为 0,说明这期间被别人改过,重试或报错适合冲突概率低的场景(用户资料编辑、配置修改)。它不加锁,读得多写得少时性能更好;代价是冲突时要重试,业务层得处理。
选择标准很简单:冲突多 → 悲观锁;冲突少 → 乐观锁。库存扣减这种热点,悲观锁或"数据库原子更新"(SET stock = stock - 1 WHERE stock >= 1)更稳;后台改配置,乐观锁足够。
10.8 一个完整的事务示例
下单:扣库存 + 建订单 + 写明细,三步必须一起成功。
BEGIN;
-- 1. 扣库存(条件里带 stock >= 数量,防止超卖)
UPDATE books SET stock = stock - 2 WHERE id = 2 AND stock >= 2;
-- 2. 建订单
INSERT INTO orders (customer_id, ordered_at, status)
VALUES (1, '2025-11-17', 'paid');
-- 3. 写明细(order_id 用刚插入的 id)
INSERT INTO order_items (order_id, book_id, quantity, unit_price)
VALUES (last_insert_rowid(), 2, 2, 49.0);
COMMIT;last_insert_rowid() 是 SQLite 取"上一条 INSERT 生成的主键"的函数,PostgreSQL 对应 RETURNING id(第 12 章讲)。
注意第 1 步的 WHERE ... AND stock >= 2:这是在 SQL 里做条件判断,而不是先 SELECT 查库存再 UPDATE。后者在并发下会超卖——两个请求都读到库存 2,都判断"够",然后都扣。把判断和扣减放在同一条原子语句里,才是安全的。
本章小结
| 要点 | 说明 |
|---|---|
| 事务 = 多条语句绑成一体 | 要么全成,要么全撤 |
| ACID 四条 | 原子、一致、隔离、持久 |
| 一致性靠应用 | 数据库不替你想业务规则 |
| 一个业务动作 = 一个事务 | 事务要短,别放网络请求 |
| 三种并发异常 | 脏读、不可重复读、幻读 |
| 隔离级别是性能换正确性 | 默认值各库不同,要查 |
| SQLite 单写者 | 不死锁,但会 database is locked |
| 死锁靠固定顺序 + 短事务 | 冲突多悲观锁,冲突少乐观锁 |
| 判断和扣减写进一条语句 | 先查再改会超卖 |
下一章
库和事务都懂了,但代码还没连上它。下一章进入应用层:怎么用 Python 安全地查库、为什么字符串拼 SQL 会被注入、连接池解决什么问题、ORM 的 N+1 是怎么来的。