Skip to content
Lv1SQL 与数据库进度 10 / 12

第 10 章:事务与并发 ​

前面九章都在假设"一次只有一个人在改数据"。现实是:下单和扣库存同时发生,两个管理员同时点保存,转账扣了钱但对方没收到。事务就是为这些时刻准备的。


学习目标 ​

  • 用一个转账例子说清"没有事务会出什么事"
  • 记住 ACID 四条各防的是什么问题
  • 会用 BEGIN / COMMIT / ROLLBACK,知道事务边界该画在哪
  • 分得清脏读、不可重复读、幻读,知道四种隔离级别各自防到哪一步
  • 知道死锁怎么发生、怎么避免,乐观锁和悲观锁各用在哪

10.1 没有事务,钱会凭空消失 ​

假设要实现转账:A 给 B 转 100 元,两步操作——

  1. A 的余额减 100;
  2. B 的余额加 100。

如果第 1 步成功、第 2 步因为网络或进程崩溃失败,A 的钱就没了。数据库里没有任何"把两步当成一步"的机制时,这种半完成状态是必然会发生的事,不是小概率。

事务要做的就一件事:把多条语句绑成一个不可分割的整体——要么全部成功,要么全部撤销,不存在中间态。

sql
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 个独立事务快一个数量级——因为每次提交都要写磁盘日志。

事务边界画在哪 ​

这是应用开发里最容易出错的地方。三条原则:

  1. 一个业务动作 = 一个事务。"下单"包含扣库存、建订单、写明细,这三步必须在一个事务里;
  2. 事务要短。不要在事务里调用外部接口、发消息、等用户输入——那会把锁持有几秒甚至几分钟;
  3. 不要在事务里做重试。失败就回滚,重试放在外层重新开事务。

反例:

python
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 模式后,读和写可以并行(读者读快照,写者写日志):

sql
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 释放 → 互相等待

数据库的检测机制会发现环路,牺牲其中一个事务(回滚并报错),另一个继续。所以死锁不会永远卡住,但会导致随机失败,业务上必须能处理这种失败(重试)。

避免死锁的四条实践 ​

  1. 固定加锁顺序:所有事务都按 id 升序更新,A 和 B 就不会交叉;
  2. 事务尽量短:持锁时间越短,撞上的概率越低;
  3. 一次批量操作排好序:UPDATE ... WHERE id IN (...) 前先 ORDER BY id;
  4. 设置锁等待超时,失败后重试,而不是无限等。

SQLite 不会出现这种死锁(只有一个写者),但会直接报 SQLITE_BUSY。到了 PostgreSQL / MySQL,死锁就是必须处理的问题。


10.7 乐观锁与悲观锁 ​

处理并发修改同一行,有两种思路。

悲观锁:先锁住,别人等着 ​

sql
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:

sql
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 一个完整的事务示例 ​

下单:扣库存 + 建订单 + 写明细,三步必须一起成功。

sql
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 是怎么来的。

👉 第 11 章:让代码安全地访问库

本文阅读--次|全站访问--次|访客--人