余额服务收到五条消息,投递顺序是 m1、m2、m2、m4、m3。第二条 m2 是重复投递,被去重逻辑挡住了。可最终余额停在 60,而正确结果应该是 70。差的那 10,来自 m3:它比 m4 先生成,却在 m4 之后才到,被当成了「最后一条」。

这次故障里,去重其实是生效的。重复的 m2 确实只处理了一次,问题不在重复,而在顺序。很多团队把「幂等」和「去重」当成一件事,结果只解决了重复,没解决乱序,账还是错的。

这篇把三个问题分开讲:重复怎么挡、乱序怎么排、以及两者叠加时怎么保证「只生效一次且按正确顺序生效」。这是本组的最后一篇,前面讲过的网络、ID、锁、事务、分片、选主,最后都会落到「一条消息到底该怎么处理」这件事上。

消息的三个老问题:重复、乱序、丢失

分布式消息系统通常只承诺「至少一次」投递,也就是不丢但可能重复。它不承诺「恰好一次」,因为在网络可能断、消费者可能崩的前提下,传输层做不到「既不丢又不重」。想要恰好一次,只能靠应用层自己补。

重复同一条消息被投递多次。去重靠唯一消息 id 或业务号。
乱序后生成的消息先到达。排序靠 seq 或版本号,不能用到达时间。
丢失消息没送到,或消费后没确认。靠重试、死信和对账兜底。

这三个问题经常同时出现。一条消息可能重复到达、顺序颠倒,还可能在重试中被延迟。只处理其中一个,另外两个仍会让结果出错。所以消费端的逻辑要同时回答:这条是不是重复、它的顺序对不对、如果处理失败该怎么重试。

还有一个容易被忽略的前提:消息的「到达时间」不等于「产生时间」。网络延迟、队列积压、重试退避,都会让后产生的消息先到。任何用「谁先到」来判断「谁更新」的逻辑,都会在乱序时出错。

「恰好一次」这个词常被误用。传输层能稳定提供的只有「至少一次」,所谓恰好一次,是应用层用「至少一次投递 + 幂等消费」拼出来的效果。它不是一个可以单独购买的队列特性,而是发送、投递、消费三段共同遵守约定的结果。少任何一段,这个效果就不成立。

幂等:同一个操作执行多次,结果只算一次

幂等的定义很直白:同一个操作执行一次和执行多次,对系统状态的影响相同。查询天然幂等,因为它不改状态;赋值也幂等,写同一个值多次结果一样;但「加一」「扣减」「插入」都不是幂等的,执行两次就多了一次。

让一个操作变幂等,常见有三种做法。第一种是「带唯一键的插入」,靠数据库唯一约束挡住重复。第二种是「状态机」,只有处于某个状态才允许推进,重复请求会因为状态已变而被拒绝。第三种是「记录已处理的业务号」,处理前先查,处理过就直接返回上次结果。

三种做法都要求「判断」和「执行」在同一个原子操作里。先查再写、中间隔着一个网络往返,两个并发请求都可能查到「没处理过」,然后都执行。真正可靠的做法是把判断放进数据库事务、唯一约束或原子脚本里,让并发在存储层被串行化。

幂等键的选择要跟业务走。订单用订单号,支付用支付流水号,退款用退款单号。用随机 UUID 做幂等键,每次重试都换一个,等于没有幂等。用「用户 ID 加时间戳」,又可能在并发时撞车。键要能唯一标识「这一笔业务」,而不是「这一次请求」。

幂等和去重的关系要分清:幂等是「结果只生效一次」的目标,去重是「靠消息 id 挡掉重复」的一种手段。去重只能挡住完全相同的消息,挡不住「同一笔业务被生成了两条不同 id 的消息」。所以真正可靠的幂等,靠的是业务号加唯一约束,而不是消息 id 加去重表。

幂等还有一个「窗口」问题。去重记录保留 7 天,第 8 天同一条消息再来,就认不出来了。窗口要覆盖消息可能重投的最长时间,超过窗口的重投只能靠业务侧的最终校验兜底。没有无限期的幂等,只有「窗口足够长」的幂等。

去重:挡住重复,挡不住乱序

去重最直接的实现是维护一张「已处理消息 id」表。每来一条消息,先查 id 在不在表里,不在就处理并写入,在了就跳过。这张表要能持久化,否则消费者重启后又认不出来,重复照样发生。

但去重只解决「同一条消息来多次」,解决不了「不同消息的顺序错」。看下面这组输出,重复的 m2 被挡住了,余额却还是 60。

投递序列: m1(seq1) m2(seq2) m2(seq2) m4(seq4) m3(seq3)
只取最后一条: balance=60(错,seq3 先于 seq4 产生,却最后到达)
只按 id 去重: balance=60(重复挡住了,顺序仍错)
去重 + seq 单调校验: balance=70(正确)

这里每条消息带的是「当前余额」的快照:seq1 是 10,seq2 是 30,seq3 是 60,seq4 是 70。按产生顺序处理,余额应该从 10 到 30 到 60 再到 70。可实际到达顺序是 m1、m2、m2、m4、m3,最后到达的 m3 带的是旧快照 60。

第一行「只取最后一条」,就是谁最后到就用谁的值,结果被 m3 的旧快照覆盖成 60。第二行「只按 id 去重」,重复的 m2 被挡住,但 m4 之后仍然处理了 m3,最终值还是 60。第三行加了 seq 单调校验,m4 的 seq4 已经处理过,m3 的 seq3 比它小,直接拒绝,余额保持在 70。

这个例子说明:去重和排序是两个独立的问题。去重看的是「这条消息是不是来过」,排序看的是「这条消息在业务顺序里该不该现在生效」。两个判断都要做,缺一个结果就会错。

顺序:seq 单调校验与水位

seq 是消息自带的顺序号,由生产端按业务维度单调递增地分配。消费端维护一个「已处理到的最大 seq」,常叫水位。新消息到来时,只有 seq 大于水位才处理,否则说明它是旧消息或者重复消息,直接丢弃或归档。

水位比「已处理 id 表」更省空间。id 表要存每一条消息的 id,水位只存一个数字。代价是水位要求 seq 严格连续,一旦中间漏了一条,后面的消息就不能处理,否则会跳过缺失的那一条。这时候要么等,要么用「按 seq 补齐」的机制。

严格连续的 seq 在分布式生产端很难保证。多个生产实例各自发号,全局连续需要额外的协调。更常见的做法是「每个分区一个 seq」,同一分区内连续,跨分区不要求顺序。消费端按分区维护水位,分区之间允许乱序。

如果业务不能接受等待,可以退一步用「允许乱序但保证最终正确」的做法:每条消息带 seq,消费端不要求严格递增,只要求「同一个业务号的消息按 seq 覆盖,低 seq 不覆盖高 seq」。这不会卡住后面的消息,但要求每条消息都能独立计算出结果,而不是依赖前一条的累积。

seq 的分配维度要和业务顺序的粒度对齐。要求「一个订单的所有操作有序」,就按订单号分配 seq;要求「一个用户的所有操作有序」,就按用户号分配。如果按全局分配,所有消息都被串到一条线上,吞吐会被一个热点业务拖死;如果按随机分配,又完全没有顺序。

# 消费端处理(伪代码)
fn consume(msg):
  if seen(msg.id): return OK              # 去重
  begin transaction
  current = get_watermark(msg.partition)
  if msg.seq <= current:
    commit; return DUPLICATE              # 旧消息,不生效
  apply(msg)                              # 按业务顺序生效
  set_watermark(msg.partition, msg.seq)
  mark_seen(msg.id)
  commit
  return OK

这段伪代码把去重、顺序、生效放在同一个事务里。任何一步失败,整个事务回滚,水位和 seen 表都不会推进,消息可以安全重试。如果分开做,比如先更新水位再写业务,中间失败就会留下「水位前进了、业务没生效」的空洞。

端到端:生产端发号,消费端兜底

顺序保证不是消费端一家的事。生产端要按业务维度分配 seq,并且保证同一个业务号的消息 seq 单调。如果生产端用时间戳做 seq,时钟回拨会让 seq 倒退;如果用随机数,根本没有顺序。seq 的来源要和分布式 ID 一样可靠。

消费端还要处理「消息处理成功但确认失败」。消费者写完了业务,还没来得及 ack 就崩了,消息会被重投。这时去重表和业务写入如果在同一个事务里,重投时能认出「已经处理过」,直接跳过;如果不在同一个事务里,就可能重复处理。这就是为什么前面强调「判断和执行要原子」。

重试策略也要配合。消费失败时,不要立刻无限重试,应该退避并记录失败次数;超过阈值转入死信,交给对账或人工。死信消息仍然带 seq 和 id,后续可以按原顺序重放。把死信直接丢掉,等于主动放弃一部分数据的一致性。

ack 的时机同样重要。业务写完、事务提交之后再 ack,是最稳的顺序;先 ack 再写,消费者一崩消息就丢了;写完但事务没提交就 ack,事务回滚后消息也丢了。正确的顺序是「业务与去重、水位在同一个事务里提交,提交成功后再确认消息」,让消息系统只在数据真正落地后才删除它。

现象真实原因第一步查什么
余额停在 60,正确应为 70去重生效但没校验 seq,旧消息覆盖了新值查消费端是否比较 seq 与水位
同一条消息被处理两次去重表没持久化,或判断与执行不在同一事务查去重表和业务写入是否原子提交
重启后重复率突然升高去重状态只存在内存里,重启丢失查去重表是否落库、是否有 TTL
后面的消息一直不处理水位卡在缺失的那条 seq 上,等不到查是否有 seq 空洞与补齐机制
并发请求都判定「没处理过」先查后写,中间有窗口查判断是否走唯一约束或原子脚本
重试后金额多扣一次操作本身不幂等,只做了消息去重查业务写入是否带幂等键
死信里的消息再也对不上死信被丢弃,没有按 seq 重放查死信保留策略与重放工具
跨分区顺序错乱误把「分区内有序」当成「全局有序」查 seq 的维度与分区键是否一致

参数怎么定:TTL、水位、重试

去重表的 TTL 要大于「消息可能重投的最长时间」。消息在队列里积压、消费者重试、死信重放,都可能让同一条消息在很久之后再来。TTL 太短,旧消息回来时认不出来,就会重复处理;TTL 太长,表会膨胀。常见做法是按业务的重试窗口设,比如 7 天。

水位要持久化,并且和业务写入在同一个事务里更新。水位可以按分区存,也可以按业务号存。按分区存省空间,但要求分区内 seq 连续;按业务号存更精确,但数量多。选哪种,取决于生产端能不能保证连续性。

# 幂等与顺序参数(示意)
consumer:
  dedupe_table: processed_msg
  dedupe_ttl: 7d
  watermark_scope: partition        # 或 business_key
  require_monotonic_seq: true
  on_seq_gap: wait_or_replay        # 等补齐,不要直接跳过
  retry_backoff: 1s..5m
  max_retry: 10
  dead_letter: true
  dead_letter_ttl: 30d

重试的退避要带抖动,避免所有消费者在同一时刻重试同一条失败消息。重试上限不要设得太小,否则一次短暂的下游故障就会把消息打进死信;也不要无限重试,否则一条毒消息会一直占着消费者。死信要有告警,不能悄悄堆积。

监控上要盯四个数:重复消息比例、seq 倒退次数、水位停滞时长、死信数量。重复比例突然升高,说明上游重投或去重失效;seq 倒退说明生产端发号或消费端校验有问题;水位停滞说明有消息卡住或分区不可用。这四个数比「消费 QPS」更能提前发现数据错误,采集也不难,难的是放进日常巡检,看到异常愿意停下来查,而不是等对账出了大问题才回头补。

边界与代价

不是所有消息都需要严格顺序。日志、通知、统计这类「先后无所谓」的消息,强行按 seq 排队只会降低吞吐,还会因为一条慢消息卡住后面所有消息。只有涉及余额、库存、状态机推进的消息,才值得为顺序付出代价。

去重表是有成本的。每条消息存一个 id,量大时这张表本身就成了瓶颈。可以按时间分区、定期清理,或者用布隆过滤器做前置判断,再用数据库做最终确认。只用布隆过滤器不行,因为它有误判,可能把没处理过的消息当成处理过。

严格顺序会牺牲可用性。水位卡在一条缺失的消息上,后面的消息就只能等。如果那条消息永远不来,整个分区就停住。所以严格顺序通常要配「超时补齐」或「跳过并记录」,在顺序和可用之间做取舍,而不是假设消息一定不会丢。

幂等不能只做在消息层。消息去重只能保证「同一条消息不重复处理」,保证不了「两个不同消息代表同一笔业务」。比如用户点了两次提交,生成两个不同消息 id,但业务上是同一笔订单。这种情况要靠业务幂等键,而不是消息 id。

顺序和分片是一对矛盾。要顺序,就把相关消息放到同一个分区;要吞吐,就分散到多个分区。分区键选业务号,能保证同一业务有序;选随机,吞吐高但顺序没了。这个取舍在分片那篇讲过,这里同样适用。

一个务实的判断:先问「这条消息乱序了会怎样」。如果只是显示顺序不对,可以不做严格排序;如果会导致金额、库存、状态出错,就必须做 seq 校验。按后果分级,比一刀切更省成本,也更容易在评审会上说清楚为什么这么做。

当天可以自验的五件事

  1. 找出一个消费接口,确认它是否同时做了「去重」和「seq 或版本校验」。
  2. 检查去重表是否持久化,重启消费者后再投同一条消息,观察是否被挡住。
  3. 构造一组乱序消息,把后生成的先投进去,确认低 seq 不会覆盖高 seq。
  4. 检查「判断是否处理过」和「写入业务」是否在同一个事务或原子操作里。
  5. 查看死信队列的保留时间和重放方式,确认死信不会被直接丢弃。

到这里,「分布式」这一组就讲完了。从网络和时钟的硬约束,到 CAP、ID、锁、事务、分片、选主,最后落到消息的幂等与顺序。这些机制没有一个是银弹,每一个都在用某种代价换某种确定性。真正要练的不是记住方案,而是每次都能说清楚:这套方案在什么条件下会坏,坏了以后业务会看到什么。