# 两个 Agent 改同一条记录，50 积分没了却没报错

> 问题出在更新丢失，会不会发生取决于客户数据库的隔离级别，而这个设置很少有工程师去查。

原文: https://fdetimes.net/zh/guides/transaction-isolation-levels-concurrent-agents/

设想一个周一早上。客户反馈某个账户扣错了积分。打开日志一看：客服 Agent 补偿了 50 积分，计费 Agent 扣了 30 积分的费用，两边都报告成功。余额本该是 120，数据库里却是 70。

按通常的标准，这段代码没有 bug。每个 Agent 都正确执行了自己的逻辑，只是它们恰好在同一时刻运行。把 Agent 部署进客户系统之后，多个进程写同一条记录就成了家常便饭。数据库里最终留下哪个数字，取决于事务怎么用，也取决于数据库运行在哪个隔离级别。

大多数工程师都知道 ACID 这个缩写，却很少有人知道客户数据库里的 I 是怎么配置的。前线部署工程师（FDE）必须知道，因为这类 bug 不抛任何异常，只会悄悄把数据弄错，等客户自己发现。

## 那 50 积分去哪了？

把两个会话按时间顺序并排摆出来，答案一目了然。两个 Agent 用的是同一套代码：读出余额，在 Python 里算出新余额，再写回去。

```sql
-- Agent A（客服）                -- Agent B（计费）
SELECT balance FROM accounts      SELECT balance FROM accounts
 WHERE id = 42;   -- 100           WHERE id = 42;   -- 100
-- 计算 100 + 50 = 150            -- 计算 100 - 30 = 70
UPDATE accounts SET balance = 150
 WHERE id = 42; COMMIT;
                                  UPDATE accounts SET balance = 70
                                   WHERE id = 42; COMMIT;
```

这就是更新丢失：后写入的一方覆盖了先写入的结果，却完全不知道对方存在过。70 是 Python 根据过期的读取结果算出来的，数据库收到的只是一个常量，照单全收。

而 Read Committed 正是 PostgreSQL 的默认级别。除非有人专门改过配置，否则这种“读取-计算-写回”的代码在两个 Agent 交错执行时毫无防护。

## 三种修复方式，各治一类问题

最简单的办法是让数据库来做运算。写成 `UPDATE accounts SET balance = balance + 50 WHERE id = 42`，加法就在语句内部完成，不会再出现上例中那种根据过期读取算出的常量。

对于加减数值的修改，优先试这种方式。即便如此，也要自己开两个 psql 窗口，在客户的真实数据库上验证一遍。

不过，Agent 往往需要先读再做决定：余额够才扣费，或者让 LLM 根据客户当前状态选择下一步动作。这时就需要悲观锁。`SELECT ... FOR UPDATE` 会像即将更新一样锁住读到的行，阻止另一个 Agent 覆盖写入。

```sql
BEGIN;
SELECT balance FROM accounts WHERE id = 42 FOR UPDATE;
-- 在第 42 行被锁住期间，在代码里做决定
UPDATE accounts SET balance = 70 WHERE id = 42;
COMMIT;
```

第三种办法针对 PostgreSQL：让事务运行在 Repeatable Read 或 Serializable 级别，并接受数据库可能以序列化错误中止事务。PostgreSQL 文档要求运行在 Repeatable Read 级别的应用必须准备好在遇到这个错误时重试。一旦发生，必须中止整个事务并从头重跑，而不是只重跑失败的那条语句。

注意，这里描述的是 PostgreSQL 的行为。MySQL InnoDB 也有一个叫 REPEATABLE READ 的级别，但名字相同不代表行为相同，别想当然地以为它能提供同样的保护。

重试循环还必须捕获第二类错误。在 psycopg 中，`SerializationFailure`（错误码 40001）和 `DeadlockDetected`（错误码 40P01）是两个独立的错误类。只捕获前者，重试循环就会漏掉死锁。

```python
import random
import time

from psycopg import errors

RETRYABLE = (errors.SerializationFailure, errors.DeadlockDetected)

def run_with_retry(conn, work, attempts=5):
    for i in range(attempts):
        try:
            with conn.transaction():
                conn.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ")
                return work(conn)  # 每次尝试都从头重新读取
        except RETRYABLE:
            if i == attempts - 1:
                raise
            # 带随机抖动的退避，避免两个 Agent 马上再次冲突
            time.sleep(0.05 * 2 ** i + random.uniform(0, 0.05))
```

这段代码最关键的一点是：`work` 每次尝试都必须重新读取数据。如果 Agent 还攥着旧的读取结果，或者攥着根据旧状态算出的 LLM 回答，重试只会把错误的值再写一遍。

`time.sleep` 这一行是带少量随机性的指数退避。没有它，两个刚冲突过的 Agent 可能立刻重试，然后再次冲突。

| 修复方式 | 机制 | 适用场景 |
|---|---|---|
| 原子更新 | 运算在语句内完成，没有过期值 | 加、减、计数 |
| `SELECT ... FOR UPDATE` | 锁住刚读到的行，另一个 Agent 无法覆盖 | 先读后决策、高争用 |
| Repeatable Read/Serializable + 重试（PostgreSQL） | PostgreSQL 以序列化错误中止事务，客户端重跑整个事务 | 低争用、逻辑复杂 |

## 快照仍会放过一类 bug

提高隔离级别之后，还剩一个陷阱。Jepsen 指出，快照隔离允许写偏斜：多个事务读取同一份共享状态，各自修改不同的对象集合，然后都成功提交。PostgreSQL 文档同样写明，Repeatable Read 能防止其表格中除序列化异常之外的所有现象，而写偏斜正属于序列化异常这一类。

假设客户有一条规则：每个账户至少要保留一位紧急联系人。账户 42 目前有两位。Agent A 删除第一位，Agent B 删除第二位。

两边都数到两位联系人，都判断删除是安全的。各自删掉不同的行，没有任何一行被写两次，所以也就没有冲突可报。最后这个账户一个能联系的人都没有了。

因此 PostgreSQL 文档提醒，在 Repeatable Read 级别下维护业务规则，如果没有仔细的显式加锁，很难做对。写偏斜的本质是双方从不触碰同一行，所以合理的修复是强迫双方经过同一行：在计数之前，对账户 42 本身那一行执行 `SELECT ... FOR UPDATE`。

另一个选择是 Serializable。PostgreSQL wiki 把写偏斜描述为可串行化快照隔离（SSI）所能防止的最简单的异常：先提交的一方胜出，另一个事务被回滚并须重新执行，这又回到了上面的重试循环。

## 隔离级别名字一样，各家数据库含义不同

FDE 从一个客户换到下一个客户时，最容易在这里栽跟头。MySQL InnoDB 默认是 REPEATABLE READ，而不是 PostgreSQL 那样的 Read Committed。CockroachDB 默认是 SERIALIZABLE，并要求客户端自己实现重试逻辑，对应错误码 40001。

Martin Kleppmann 在测试 ACID 中 I 的项目 Hermitage 里指出，repeatable read 这样的名字在不同数据库里含义各不相同。

**要点:** 两个数据库用着同一个隔离级别名称，仍可能给出两种不同的结果。

后果很直接。上一个项目里在 CockroachDB 上跑得好好的 Agent 代码，如果依赖数据库来拦截冲突，换到默认配置的 PostgreSQL 上就可能弄坏数据。反过来，为 PostgreSQL 写的、不带重试的代码，到了 CockroachDB 上会碰到无人处理的 40001 错误。要查实际配置，别凭记忆。

## 锁多了，又带来新风险：死锁

一旦用上 `FOR UPDATE`，就会遇到死锁：Agent A 锁住账户、等待发票，Agent B 锁住发票、等待账户。PostgreSQL 会检测到这种情况，并中止其中一个事务，让其他事务继续执行。

死锁和序列化失败是不同的错误，所以即使在 Read Committed 级别也需要重试循环，而且必须像上面的代码那样捕获 `DeadlockDetected`。MySQL 文档给出的建议类似：始终做好准备，重新执行因死锁而回滚的事务。

按照 PostgreSQL 文档的说法，最好的防御是让所有应用以相同的顺序锁定多个对象。可以为整个 Agent 系统定一条约定，比如总是先锁账户再锁发票，或者按 id 升序加锁，然后把这条约定写进交接文档，免得客户团队日后把它破坏掉。

## 客户现场的常见陷阱

最常见的陷阱是放任 Agent 生成“读取-计算-写回”的 SQL，却没人检查其中的争用问题。同样常见的还有：重试时不重新读取数据；重试接连触发、没有退避；重试只捕获序列化失败，却忘了死锁。

Agent 系统特有的陷阱，是在等待 LLM 响应时一直开着事务。MySQL 文档建议让事务保持小而短，以减少冲突。所以应当先读数据，在事务之外调用模型，再开一个短事务重新检查并写入。

下次在让第二个 Agent 写同一张表之前，先问自己：如果两个 Agent 在同一毫秒运行，最后留下的会是哪个数字？在 FDE 面试中，讲清楚自己曾经发现并修复过这样一个更新丢失问题，远比技能清单上写一个“PostgreSQL”更有说服力。

**本周动手试试:**

- 在客户代码库中找出所有“读取记录、在代码里计算、再 UPDATE”的地方，标出可能被两个 worker 或 Agent 同时触发的位置
- 打开两个 psql 窗口，先在 Repeatable Read、再在 Serializable 级别重现“两位紧急联系人”的场景，记下每个级别下看到的错误
- 检查现有的重试循环，确认它们同时捕获 SerializationFailure（40001）和 DeadlockDetected（40P01），并在两次尝试之间做退避

## 信源

- [13.2. Transaction Isolation (PostgreSQL 18 Documentation)](https://www.postgresql.org/docs/current/transaction-iso.html)

- [PostgreSQL: Documentation: 18: 13.3. Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)

- [MySQL 8.0 Reference Manual :: 17.7.2.1 Transaction Isolation Levels](https://dev.mysql.com/doc/refman/8.0/en/innodb-transaction-isolation-levels.html)

- [MySQL 8.0 Reference Manual :: 17.7.5.3 How to Minimize and Handle Deadlocks](https://dev.mysql.com/doc/refman/8.0/en/innodb-deadlocks-handling.html)

- [Snapshot Isolation (Jepsen)](https://jepsen.io/consistency/models/snapshot-isolation)

- [Transactions (CockroachDB Docs)](https://docs.cockroachlabs.com/docs/stable/transactions)

- [Hermitage: Testing the “I” in ACID](https://martin.kleppmann.com/2014/11/25/hermitage-testing-the-i-in-acid.html)

- [SSI](https://wiki.postgresql.org/wiki/SSI)

- [errors – Package exceptions](https://www.psycopg.org/psycopg3/docs/api/errors.html)
