一次跨服务的下单支付,协调者在第 10 毫秒发出 prepare,三个参与者都在第 12 毫秒回复 yes,资源各自锁住。第 18 毫秒协调者决定提交,第 20 毫秒把 commit 发给 P1 和 P2,第 22、23 毫秒两方先后提交成功。
发给 P3 的那条 commit 消息在路上丢了。P3 不知道应该提交还是回滚,只能保持 prepared 状态,行锁和本地事务一直不释放。到第 60 秒它还在等,而它的连接池已经被这个悬着的事务占住,后续请求开始排队,整个服务跟着变慢。
这就是分布式事务最典型的困境:一旦进入「已经决定提交、但有人没收到通知」的状态,就没有既安全又快的退出方式。这篇按三种主流做法展开,讲清各自的代价,以及为什么很多系统最后选了看起来最「不严谨」的最终一致。
本地事务跨不过进程
单库事务靠数据库自己的锁、日志和回滚机制保证原子性,一组写要么全成功,要么全失败。可一旦这组写分散到两个服务、两个数据库,数据库的本地事务就管不到对方了。A 库提交成功,B 库提交失败,中间没有任何机制能自动把 A 撤回来。
分布式事务要解决的正是这个:让多个独立资源上的操作,表现出「一起成功或一起失败」的效果。难点不在「成功时怎么提交」,而在「中途出错、消息丢失、参与者失联时,怎么收场」。所有方案的分歧,都出在收场方式上。
先明确一个前提:跨进程之后,你无法同时拿到「强一致」和「高可用」。想要任何时刻都一致,就得在不确定时阻塞或拒绝;想要一直可用,就得允许一段时间的不一致,再靠补偿追平。三条路分别对应:两阶段提交偏一致,TCC 偏可控的中间态,消息最终一致偏可用。真实跨机房两阶段提交的耗时、协调者切换与消息中间件事务行为,未在本机实测。
两阶段提交:先投票,再执行
两阶段提交把一次事务拆成两步。第一步 prepare,协调者问所有参与者「能不能提交」,参与者把资源锁住、写好日志,回复 yes 或 no。第二步 commit,如果所有参与者都回 yes,协调者就通知大家真正提交;只要有一个回 no,就通知大家回滚。
两阶段提交:
t=10 协调者发 prepare
t=12 P1 prepared,资源已锁定
t=12 P2 prepared,资源已锁定
t=12 P3 prepared,资源已锁定
t=18 三方都 yes,协调者决定 commit
t=20 发 commit 给 P1、P2
t=22 P1 committed
t=23 P2 committed
t=20 发往 P3 的消息丢失
t=60 P3 仍 prepared,行锁与本地事务一直不释放
两阶段提交的代价:P3 只能一直等,没有超时自动放弃的合法选择,否则可能和已提交的一方不一致。
这组时间线里最要命的是最后一句。P3 已经投了 yes,它就不能自己决定回滚,因为协调者可能已经让 P1、P2 提交了。它也不能自己决定提交,因为协调者可能最终决定回滚。它唯一能做的就是等,等到协调者的下一个指令。这个「等」没有合法上限。
所以两阶段提交的代价很具体:参与者会在 prepared 状态停留任意长时间,期间锁着资源。锁着行、占着连接、占着事务日志,时间一长就把资源池拖垮。协调者如果也挂了,参与者甚至不知道该找谁,只能等协调者恢复。
它还有一个隐性成本:性能。每个参与者都要多一次网络往返,协调者要维护事务状态,参与者的锁持有时间被拉长。跨机房时,一次两阶段提交的耗时可能是本地事务的好几倍。对高并发写入,这个开销很难接受。
协调者本身也是个单点。它挂了,所有参与者都停在 prepared,谁也不知道最终该提交还是回滚。后来的改进版加了「预提交」阶段,让协调者在真正提交前先确认自己能推进,但它并没有消除「参与者等待」这件事,只是把窗口缩短了一点,代价是多一次往返。协调者的高可用部署细节未在本机实测。
TCC:把「锁资源」换成「预留资源」
TCC 是 Try、Confirm、Cancel 三个字母的缩写。它把一次业务操作拆成三段:Try 阶段先做资源检查和预留,比如冻结一部分余额、预占一部分库存;Confirm 阶段确认使用这笔预留;Cancel 阶段释放预留。三个阶段都由业务代码实现,不依赖数据库的长事务。
TCC:
t=10 TCC Try:P1/P2/P3 各自预扣资源,预留有效期 30s
t=20 Confirm 发给 P1、P2;P3 消息丢失
t=50 P3 预留到期,自动释放并回调业务取消
t=52 对账发现 P3 未确认,触发补偿
TCC 的代价:每个参与者都要写 Try / Confirm / Cancel 三段,还要处理空回滚与幂等。
和两阶段提交比,TCC 最大的不同是「不留长事务锁」。Try 阶段只是把资源标成预留,业务表本身可以正常读写,数据库不会因为一个悬着的事务被锁死。P3 的预留到期后自动释放,就不会出现前面那种行锁卡 40 秒的情况。
代价转移到了业务代码。每个参与者都要实现三段逻辑,而且三段都要幂等。Confirm 可能被重复调用,Cancel 也可能被重复调用,重复执行不能产生额外效果。这比写一个本地事务复杂得多,尤其是在业务逻辑本来就绕的服务里。
还有两个必须处理的边界。第一个叫空回滚:Cancel 先到了,可 Try 根本没执行过,这时不能把「没预留过的资源」当成预留来释放,否则会误伤。第二个叫悬挂:Cancel 已经执行完,Try 才姗姗来迟,结果资源被预留住,却再也不会有人 Confirm 或 Cancel,一直挂着。
处理空回滚和悬挂,通常要给每个事务加一张状态表,记录「Try 是否执行过、是否已 Cancel」。Cancel 到来时先查状态,没 Try 过就标记为「已空回滚」,等 Try 真来了再直接拒绝。这套状态机不难写,但漏掉任何一个分支,都会在低频故障里留下一个永远解不开的结。
Try 阶段也不只是「加个锁」。它必须真的把资源预留下来,比如把可用余额转到冻结余额,并且这个变更要能被 Confirm 转成正式扣减、被 Cancel 释放回去。如果 Try 只是检查一下余额够不够、什么都不占,那么并发请求会在 Confirm 阶段抢同一笔钱,TCC 就退化成了没有互斥的普通调用。
消息最终一致:先落本地,再投递
很多业务其实不需要「同一瞬间全部一致」,只需要「最后都对上」。这时候更划算的做法是消息最终一致:本地业务和「待发送消息」写在同一个本地事务里,提交成功后由后台把消息投出去,对方消费成功后再推进状态。
关键在「消息和业务在同一个本地事务里落库」。如果先写业务再发消息,发消息失败就丢了;如果先发消息再写业务,业务失败就多发了一条。把消息存成业务库里的「待发件箱」记录,两者一起提交,就消灭了这个时间差。这个模式常叫本地消息表,或者发件箱模式。
# 本地消息表(伪代码,和业务同一个本地事务)
begin
insert into orders (...) values (...)
insert into outbox (id, topic, payload, status)
values (order_id, 'order.created', payload, 'pending')
commit
# 独立投递器轮询 outbox,投递成功后改状态
fn relay():
for row in outbox where status = 'pending' order by id:
if send(row.topic, row.payload) succeeds:
update outbox set status = 'sent' where id = row.id
else:
retry with backoff
这套做法不保证「对方一定马上处理」,只保证「消息最终会被投出去」。对方可能重复消费,所以消费端必须幂等;对方可能延迟消费,所以业务要能接受一段时间的中间态。它的好处是没有长事务、没有跨服务锁,任何一个环节挂掉都能靠重试恢复。
消费端幂等通常靠「业务号加消费状态表」:每条消息带一个唯一业务号,消费前先看这个号有没有处理过,处理过就直接跳过。状态要和业务写入在同一个事务里落库,否则「业务写了、状态没写」还会重复。另一个办法是用数据库的唯一约束兜底,让重复插入直接冲突失败。
也有「事务消息」的变体,由消息中间件保证「本地事务提交后消息一定发出」。它把发件箱的活挪到了中间件里,用起来更省事,但依赖中间件的可靠性,出了问题排查起来也更绕。关于真实消息中间件事务消息的集群行为,未在本机实测。
补偿与对账:最后一道网
无论选哪种方案,都需要一层「事后对账」。因为总有一些情况是实时机制兜不住的:消息丢了、参与者超时、人工误操作、代码分支漏了。对账的作用是定期把两边的流水按业务号比一遍,找出「这边有、那边没有」的差异,再触发补偿。
补偿不是简单的「反向操作」。扣了款要退款,但退款本身也可能失败;发了货要取消,但货可能已经签收。所以补偿动作必须幂等、必须有唯一业务号、必须记录执行结果,还要有人工兜底的出口。把补偿写成「再调一次接口」,很容易在重试里越补越乱。
对账的粒度也要选。按天全量对,能发现所有差异,但延迟高;按小时增量对,发现快,但可能漏掉跨小时的边界情况。比较稳的做法是「增量高频对账 + 全量低频兜底」,增量负责及时发现,全量负责收尾。对不上时不要自动改数据,先把差异列出来,确认原因再补偿,顺序反了很容易把小差异放大成大事故。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 一方已提交,另一方一直不提交 | commit 消息丢失,参与者停在 prepared 状态 | 查协调者的事务状态与参与者的待处理指令 |
| 服务连接池被占满,接口变慢 | 悬着的 prepared 事务锁住行和连接 | 查数据库里长时间未结束的事务 |
| Cancel 执行了,资源却仍被预留 | 空回滚之后 Try 才到,形成悬挂 | 查事务状态表里 Try 与 Cancel 的先后记录 |
| 同一笔退款被执行两次 | 补偿动作不幂等,重试又退了一遍 | 查补偿是否有唯一业务号和执行记录 |
| 消息发出去了,业务却没变化 | 只保证投递,消费端处理失败后没有重试 | 查消费位点与失败消息的重试记录 |
| 本地事务成功,消息没发出去 | 消息和业务没在同一个事务里落库 | 查是否存在独立的发消息步骤 |
| 对账每天都有少量差异 | 跨小时边界或重试窗口造成的时序问题 | 查差异记录的业务时间与重试次数 |
| 人工补偿后账还是不平 | 补偿只改了一边,另一边没有对应动作 | 核对两边流水号与补偿记录是否成对 |
这张表里的问题,有一半不是「选错方案」,而是「方案选对了但边界没处理」。分布式事务的复杂度,几乎全部集中在这些低频但致命的边界上。
参数怎么定:超时、预留期、重试
两阶段提交里,参与者的等待不能设「自动放弃」,但可以设告警。超过一定时间还停在 prepared,就报警让人介入,而不是让程序自己决定。协调者的状态要持久化,重启后能继续推进,否则参与者永远等不到指令。
TCC 的预留有效期要大于「正常 Confirm 的最长延迟」,否则预留会在 Confirm 到达前就释放,Confirm 来了发现没资源可确认。设得太长,悬挂的资源会占用很久。常见做法是预留期设为业务超时的两到三倍,并配一个到期自动 Cancel 的扫描任务。
# 事务参数(示意)
tcc:
try_reserve_ttl: 30s # 预留有效期
confirm_timeout: 10s # 单次 Confirm 超时
cancel_retry_max: 5 # Cancel 重试上限
state_table: tcc_tx_state # 记录 Try/Confirm/Cancel
expire_scan_interval: 5s # 扫描到期预留
outbox:
poll_interval: 1s
batch_size: 100
max_retry: 10
retry_backoff: 1s..5m
消息投递的重试要无限接近「直到成功」,但每次间隔要退避,避免打爆对方。重试次数用完后不能直接丢弃,应该转入死信表,由对账或人工处理。死信不是垃圾,它是「已知没有送达」的证据,丢掉就等于放弃一致性。
所有这些参数都要能被观测。至少要能看到:prepared 停留时长、预留到期数量、空回滚次数、悬挂次数、死信数量、对账差异数。没有这些指标,方案只是纸面上成立,出了事只能靠猜。
发件箱表还要有清理策略。投递成功的记录不能永久留着,否则表会越来越大,轮询越来越慢。常见做法是保留一段时间供排查,之后归档或删除。清理前要确认没有下游还在按这条记录重试,否则删了之后对方再来问,就查不到原始消息了。
边界与代价
能用本地事务就别用分布式事务。把相关的表放在同一个库,用数据库事务解决,是最便宜的方案。很多「跨服务」其实是人为拆出来的,拆之前先问一句:这两份数据真的需要独立扩缩容吗。为了微服务而拆散一个本来可以本地事务完成的操作,是在给自己制造难题。
两阶段提交适合低并发、强一致。参与方少、写入不密集、不能容忍中间态的场景,它最直接。高并发写入、参与方多、跨机房,它的锁和往返开销会被放大,通常不划算。
TCC 的成本被低估。它要求每个参与者都实现三段逻辑,还要处理空回滚、悬挂、幂等。参与者越多、业务越复杂,这套状态机越难维护。它适合核心交易链路,不适合给所有业务都套一层。
最终一致要接受中间态。选了它,就要允许用户在一段时间内看到「订单已创建、权益还没到账」。这需要产品层面配合,比如给出「处理中」的提示,而不是假装一切已经完成。技术上能做到最终一致,产品上不承认中间态,照样会变成投诉。
分布式事务不能替代业务对账。再严谨的协议,也会遇到消息丢失、人工操作、代码 bug。对账是最后一道网,不是可选项。把对账做扎实,比在协议上追求完美更实际。
当天可以自验的五件事
- 列出一次跨服务业务涉及的所有写入点,标注它们是否在同一个本地事务里。
- 找出系统里所有「先写业务再发消息」的代码,评估消息发送失败时会不会丢数据。
- 检查是否存在独立的消息表和业务表,确认两者是否在同一个事务中提交。
- 对一笔补偿动作连续执行两次,确认第二次不会产生额外扣款或退款。
- 在测试环境模拟一次 Confirm 丢失,观察预留是否到期释放、是否留下悬挂记录。
事务解决了「一次操作要么全成要么全败」,可当数据量大到一台机器放不下时,还要解决「数据放在哪、怎么找」。下一篇《分片与路由:数据怎么切、扩容时怎么搬》会从一次扩容后 89% 的键都要迁移讲起,对比取模哈希和一致性哈希的代价。