外观
30 - 超时后余额又扣了一次:Deadline、幂等与并发重试
摘要
客户端超时,服务器却已经提交,重试再次扣款。本文用真实 SQLite 事务与四线程竞争,解释截止时间、取消和操作状态的边界,给出同键重试、异参数拒绝与事务 outbox 的最小实现。
实验使用 Python >=3.13、标准库和临时 SQLite 文件。四线程幂等及提交后等待超时已在 CPython 3.13.7、SQLite 3.50.4 执行;3.14复查见统一报告。网络数据库提交中断、分布式锁及真实消息投递待验证。
1. 场景:失败的是响应,不是扣款
教学接口把30从账户A转到B,数据库提交成功,响应却没有及时到达。客户端看到超时,不能据此知道服务端有没有提交。若换一个请求标识再执行,数据库会把它当另一笔合法转账:总额仍守恒,但余额变化两次。事务保护了每次执行内部的原子性,没有识别两次执行属于同一业务意图。
第16篇已用单连接展示提交后丢响应,本篇增加真实并发与时间预算:四个线程同时提交同一操作标识;不同参数复用标识被拒绝;已提交的工作等待响应超过期限后,查询原结果仍能得到成功状态。故障由本地控制点注入,不声称复现了生产网络故障。
每次恢复都追三个坐标:这是哪个逻辑操作、业务走过COMMIT没有、现在结束的是哪个等待者。操作标识(operation ID)固定业务身份,事务边界决定副作用是否提交,超时(timeout)只说明等待预算耗尽。三者分开,才不会把响应失败推导成扣款失败。
取一个操作标识same-op,金额固定为30,先预测四次请求应该对应几次扣款;再只改变金额,预测同键必须冲突;最后保持一个已经提交的操作,只延迟响应,预测等待超时而余额不回退。后文的唯一键、事务与等待保护分别兑现这些判断,不是三种可互换的“防重复工具”。
2. Timeout与Deadline:相同数字,不同约束
timeout(超时)描述某次等待最多允许多久;deadline(截止时间)描述整条操作最晚允许到什么时候。若调用三层服务,每层重新给两秒,端到端预算可能超过两秒很多。绝对截止时间在入口建立,下游得到剩余预算,排队和重试同样消耗预算。
本地持续时间用 time.monotonic(),它的单调性质适合计算经过时间;不把系统墙上时钟调整混进剩余预算。Python时间文档说明其参考点未定义,因此不能把本机单调时钟数值直接传给另一台机器当共同时间坐标。跨进程、跨机器传播应约定时间预算或可比较的协议时间,并处理时钟差异。
每次进入下一阶段都计算 max(0, deadline-now)。预算为零时不再启动新的可避免工作;给驱动设置相应超时还要考虑连接、获取、执行、提交和响应等待是否分别受控。仅在最外层包一个协程超时,并不能证明所有底层同步调用都能中止。
预算也不是“把每个阶段平分”就足够。请求要留下收尾预算,例如回滚、释放连接和记录操作状态。最后毫秒启动一个不可安全取消的提交,会增加未知状态。系统应根据业务阶段选择停止准入、查询状态或让已开始的短事务收尾,不能把等待终止和业务撤销当成同一操作。
图表将在阅读到此处时加载…
这张图没有保证每次超时都发生在提交之后。提交前失败、提交时未知、提交后响应失败需要分别建模,日志要保存阶段与操作标识。
3. 幂等键必须绑定请求语义
idempotency(幂等)在这里指同一逻辑操作重复请求不会重复产生业务效果,并能返回原结果。操作表包含唯一 ID、规范化 payload 与 result。使用同 ID、同参数时返回原结果;同 ID、不同金额时拒绝,避免错误客户端复用键得到看似成功的旧响应。 可进一步阅读幂等性与重复请求:重复请求协议区分同键同内容与冲突。
canonical payload(规范化请求表示)保证语义相同的请求使用稳定比较方式。示例只有整数金额,通过有序 JSON 保存,不存在复杂浮点或字段默认值。真实接口应明确字段白名单、默认值、币种、租户和版本,不能直接比较随机键顺序的原始 JSON。金额通常采用经过验证的整数最小单位或精确定点表示,不用二进制浮点偷渡金融规则。
唯一范围还必须包含业务主体。两个租户使用相同操作字符串不能互相取得结果;应把租户身份纳入约束或可靠派生键,同时在查询原结果前授权。请求标识与幂等标识也不同:每次 HTTP 尝试可以有不同 request ID,但必须保留同一逻辑 operation ID,便于区分调用尝试和业务次数。
返回原结果还涉及结果保留期、敏感字段、进行中状态和失败语义。删除幂等记录后,迟到重试可能再次执行;保留期需要长于协议允许的重试窗口,不能单凭数据库容量决定。参数验证失败是否留记录、业务拒绝能否重试、结果版本变化如何处理,都要写进接口契约。
本实验只有已提交成功状态,写事务进行中由 SQLite 锁等待串行化,未实现分布式“处理中”状态、租户鉴权和自动过期。明确边界比把它命名成完整生产幂等框架更有帮助。
4. 为什么先查后写必须在同一数据库边界内
两个并发请求都在事务外 SELECT,看不到记录,然后分别修改余额,最后才争抢唯一键:后一个插入失败,不代表其业务修改已经撤销。如果修改已经自行提交,唯一键只证明重复被发现,不能修复重复效果。
示例先 BEGIN IMMEDIATE,再检查操作记录、条件扣款、增加收款余额、插入原结果与 outbox,最后提交。SQLite 的写者串行化使第二请求等待第一个结束,随后读到已有记录。这是 SQLite 的实测方案,不是 PostgreSQL 行锁或所有数据库默认隔离的结论。
扣款使用 UPDATE ... WHERE balance>=amount 并检查 rowcount,避免先读余额后修改造成竞争窗口。SQL结构参数化,金额在入口检查正整数,特别拒绝 bool:Python 中 bool 是 int 的子类,如果只写 isinstance(amount,int),True 会通过。数据库约束和应用验证相互补充,不能互相替代。
出现任何异常时,如果连接仍处于事务中才回滚,finally 关闭连接。对于网络驱动,提交异常可能表示未知状态,不能沿用本地 SQLite 的“连接没有网络”假设。必须用操作标识查询真实业务状态,无法查询时进入可恢复流程,不无限重试写操作。
四线程通过Barrier(线程同步屏障)一起进入相同ID的操作,各自创建与关闭连接。追踪业务状态时,不需要猜谁先取得写者位置:首个完成的新操作把100/0改为70/30,并保存same-op结果;其余请求进入写事务后看到该记录,参数相同就返回70/30,不再扣款。原结果全部相等和操作表唯一这一对断言,比线程完成顺序更重要。
只把金额改为20,标识不变,结果应是参数冲突而非再扣20。唯一键识别身份,payload比较识别意图一致,两步缺一不可。实验给屏障与锁等待设置上限,不绕过SQLite线程检查,也不把这种写者串行化推广为所有数据库默认行为。
5. CancelledError不会倒转COMMIT
独立实验将短事务放进 asyncio.to_thread,线程完成真实转账后设置 committed 事件,再等待响应控制点。主协程确认提交已经发生,然后用剩余预算等待操作。asyncio.shield 使外层等待超时不直接取消操作 Task,但不让等待者无限等下去。
asyncio任务文档提醒保留任务强引用。示例保存 operation,finally 释放响应控制点并 await 收割结果,确保线程有界结束。没有把后台任务扔掉,让它成为无法观察的“仍在运行”工作。
这不是建议所有数据库事务都用 shield。短、明确收尾、状态可查询的操作才有讨论基础;长事务、外部网络调用或不受控循环不能用 shield 隐藏。客户端退出后继续工作的容量必须有上限,否则大量超时请求会留下大量后台执行,问题转移到线程池和连接池。
把三个坐标放进响应超时实验:
| 观察位置 | 业务身份与状态 | 等待者状态 |
|---|---|---|
| transfer完成并设置committed | deadline-op金额10已提交,余额60/40 | 线程还在等待release_response |
| 剩余0.2秒教学预算耗尽 | 同一业务没有被撤销 | 外层等待得到TimeoutError |
finally释放并await operation | 结果收割,线程结束 | 再用deadline-op查得相同60/40 |
这张轨迹的前提是committed事件真的已置位;没有这个证据时不能套用“超时但成功”的结论。时长不用于性能比较,主例固定的是提交位置与业务结果。shield仅保护这条取消传播路径,最后仍由拥有者收割,不能因此制造无限后台工作。
取消请求与业务撤销若都需要,应设计不同接口:取消尚未开始的任务、申请撤销已完成业务,可能属于补偿操作。补偿也会失败,也需自己的幂等与授权,不能通过删除操作表假装事务从未发生。
6. Outbox:把要发的消息与业务状态一起保存
outbox(事务发件箱)把待投递事件保存在业务事务中,提交成功就同时留下业务修改与投递意图。示例每次新操作写一条 outbox,相同键重试不新增;两次不同业务操作结束后 outbox 数为二。这里实测的是保存一致性,不是消息已经发送。
直接在事务里调用消息系统会增加持有时间,还无法天然组成一个跨系统原子提交。先提交再发送,发送失败会丢事件;先发送再提交,回滚可能留下无对应业务的事件。事务 outbox 给投递器一个可恢复的数据库来源,但投递器发送后标记成功之前崩溃,仍可能重复发送。
所以消费者还要基于事件 ID 幂等,投递器要记录尝试、错误和下一次重试时间,避免无限忙循环。多个投递器如何领取记录、租约过期和失败恢复,依赖目标数据库与部署模型,本篇未实测。不能把“有 outbox 表”写成 exactly-once(端到端恰好一次)保证。
当队列需要承接发件箱任务,可以参考有界后台任务队列,但内存队列不能替代持久记录。进程重启后,应从数据库恢复待投递任务;队列容量只是限制并发和内存,不提供持久性。
7. 运行与独立能力任务
完整文件30_deadline_idempotency.py仅用标准库,运行:
powershell
python docs/python/examples/30_deadline_idempotency.py已实测输出包含 response deadline exceeded; commit already happened,最终余额为60/40,操作与 outbox 各两条。四线程返回值、异payload拒绝和数量由断言检查。运行时打印 SQLite 版本;线程启动顺序不做保证,业务最终状态才是验收对象。
独立任务第一步:在提交前主动抛异常,验证余额和操作表都不变。第二步:提交后重复同键四次,验证只有一次扣款。第三步:同键变金额必须拒绝。第四步:把请求等待预算缩短,确认是否已提交并通过原键查结果,不能只断言“出现超时”。
验收应记录余额、业务记录数量、outbox数量和连接关闭状态。首次实测发现直接使用 sqlite3 的事务上下文并未关闭连接,Windows 临时文件删除失败;修复使用 contextlib.closing。这项错误说明“正确提交”与“资源释放”是两个不变量,恰好与连接池篇形成互证。
8. 踩坑与排障推演
容易踩的坑是每次重试生成新 operation ID。服务端再严谨的幂等也无法识别它们属于同一业务意图。另一个坑是把所有异常都重试,包括参数错误、余额不足和同键异参数;这些错误需要修正请求或改变业务决策,重试原请求只会重复失败。
重试需要有限次数、整体预算与退避策略,并考虑同时失败时的请求风暴。抖动可以分散重试时刻,却不能代替容量控制。观察每个操作的尝试次数与阶段,指标标签采用低基数分类,operation ID 放日志与追踪,参见日志指标追踪。
面试问“超时后能否重试”,先说提交状态是否确定,再说业务是否幂等,再说剩余预算与失败分类。问“唯一键够不够”,解释业务修改与操作记录必须同事务,以及并发等待和异参数行为。问“shield解决什么”,解释它保护任务免于这条等待链的取消,却不回滚提交、不提供持久化,也不提供无限资源。
设计重试协议时要说明调用方义务
接口文档应给出操作标识生成时机:在用户确认一次业务意图时产生,随后所有网络尝试沿用;用户发起另一笔业务时才换键。调用方收到超时后先查询原操作,若查询也失败,保留待确认状态,不能以“没有查到响应”推断失败后立即重新扣款。服务器要说明不存在、处理中、成功和不可重试失败各意味着什么。
相同键的结果不是随意复用缓存。必须先验证授权与参数一致,再返回原结果;若结果含敏感字段,查询者应与原业务主体匹配。新版本改变返回字段时,保存结果与重新构造响应的策略不同:前者稳定但需版本兼容,后者可能读取变化后的业务状态,不能再叫原始操作结果。示例固定结果字典,未处理跨版本转换。
对于可重试的瞬时错误,尝试次数、总截止时间和单次超时要共同约束。退避期间也消耗预算,不能每次睡醒重置全部预算。事务持有期间禁止长时间退避等待远端恢复,否则一条恢复逻辑可能占着连接阻塞其他正常业务。是否重试应在释放失败事务、确认连接状态后判断。
把这套判断迁移到日志导入:operation ID改为租户内导入键,金额改为规范化记录批次,余额改为已保存记录与原导入结果。相同键、相同内容返回原结果,不同内容拒绝,记录与操作状态同事务;响应等待仍单独受预算约束。业务换了,身份、提交位置与等待者的三个坐标没有变。
验收也必须跟着业务变化。转账只看总额守恒,会漏掉重复扣款;日志只看HTTP成功,会漏掉重复导入。分别检查业务操作数、实际行数、outbox意图数与异内容拒绝,才能证明幂等覆盖的是重复效果,而不是只加了一条唯一约束。
9. 结尾
超时约束等待,事务约束提交,幂等约束重复业务效果,三者必须分别设计并关联状态证据。
- 传播整体剩余预算,取消等待不代表撤销底层提交。
- 操作键绑定参数与业务主体,同键重试返回原结果、异参数拒绝。
- outbox保存投递意图,真正投递仍需要恢复、重试与消费者幂等。
参考与完整代码
python
"""SQLite 并发幂等、提交后丢响应、deadline 不撤销事务。"""
import asyncio
from contextlib import closing
from concurrent.futures import ThreadPoolExecutor
import json
from pathlib import Path
import sqlite3
import tempfile
import threading
import time
def transfer(path, operation_id, amount):
if not isinstance(amount, int) or isinstance(amount, bool) or amount <= 0:
raise ValueError("positive integer required")
payload = json.dumps({"amount": amount}, sort_keys=True)
connection = sqlite3.connect(path, timeout=2, autocommit=True)
try:
# SQLite 写者串行化;不把它称为 PostgreSQL 行锁实测。
connection.execute("BEGIN IMMEDIATE")
prior = connection.execute(
"SELECT payload,result FROM operations WHERE id=?", (operation_id,)
).fetchone()
if prior is not None:
if prior[0] != payload:
raise ValueError("operation id payload mismatch")
result = json.loads(prior[1])
else:
changed = connection.execute(
"UPDATE accounts SET balance=balance-? WHERE id='a' AND balance>=?",
(amount, amount),
).rowcount
if changed != 1:
raise ValueError("insufficient funds")
connection.execute("UPDATE accounts SET balance=balance+? WHERE id='b'", (amount,))
result = dict(connection.execute("SELECT id,balance FROM accounts"))
connection.execute(
"INSERT INTO operations VALUES(?,?,?)",
(operation_id, payload, json.dumps(result, sort_keys=True)),
)
# 外部发送由后续投递器执行,不放在事务里面。
connection.execute("INSERT INTO outbox VALUES(?,?)", (operation_id, payload))
connection.execute("COMMIT")
return result
except BaseException:
if connection.in_transaction:
connection.execute("ROLLBACK")
raise
finally:
connection.close()
async def deadline_experiment(path):
committed = threading.Event()
release_response = threading.Event()
def slow_response():
result = transfer(path, "deadline-op", 10)
committed.set()
if not release_response.wait(2):
raise TimeoutError("test response gate")
return result
operation = asyncio.create_task(asyncio.to_thread(slow_response))
deadline = time.monotonic() + 0.2
try:
# 先确认真实提交发生,再制造响应等待耗尽预算。
async with asyncio.timeout(1):
while not committed.is_set():
await asyncio.sleep(0)
remaining = max(0, deadline - time.monotonic())
try:
await asyncio.wait_for(asyncio.shield(operation), timeout=remaining)
except TimeoutError:
print("response deadline exceeded; commit already happened")
finally:
release_response.set()
result = await operation # 保留任务引用并收割,避免遗留后台任务。
assert result == {"a": 60, "b": 40}
assert transfer(path, "deadline-op", 10) == result
def main():
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / "bank.sqlite"
with closing(sqlite3.connect(path, autocommit=True)) as connection:
connection.executescript("""
CREATE TABLE accounts(id TEXT PRIMARY KEY,balance INTEGER NOT NULL);
INSERT INTO accounts VALUES('a',100),('b',0);
CREATE TABLE operations(id TEXT PRIMARY KEY,payload TEXT,result TEXT);
CREATE TABLE outbox(id TEXT PRIMARY KEY,payload TEXT);
""")
start = threading.Barrier(4)
def concurrent_retry():
start.wait(timeout=2)
return transfer(path, "same-op", 30)
with ThreadPoolExecutor(max_workers=4) as executor:
futures = [executor.submit(concurrent_retry) for _ in range(4)]
results = [future.result(timeout=5) for future in futures]
assert all(result == {"a": 70, "b": 30} for result in results)
try:
transfer(path, "same-op", 20)
except ValueError as error:
assert "mismatch" in str(error)
else:
raise AssertionError("mismatched payload accepted")
asyncio.run(deadline_experiment(path))
with closing(sqlite3.connect(path)) as connection:
assert connection.execute("SELECT COUNT(*) FROM operations").fetchone()[0] == 2
assert connection.execute("SELECT COUNT(*) FROM outbox").fetchone()[0] == 2
print("sqlite:", sqlite3.sqlite_version, "balances:", dict(connection.execute("SELECT * FROM accounts")))
if __name__ == "__main__":
main()