一次支付回调联调,客户端把单次调用超时设成 50ms,服务端处理一笔回调平均要 80ms。压测发了 30 次请求,客户端 30 次全部超时,可服务端那边 30 笔写入一笔没少。

更麻烦的是客户端带了三段自动重试。第一次判超时后立刻重发,第二次又写了一遍,同一笔业务被写了 2 次,账上多出两条记录。客户端从头到尾没收到失败响应,它只是没等到结果。

客户端超时 50ms,服务端实际 80ms:
30 次请求中,客户端超时 30 次,服务端最终都执行了写入
其中重试后成功 30 次,等于同一笔业务被写了 2 次
结论:超时不等于失败,它只说明「没等到结果」

这组数字里最该记住的是「30 次超时、30 次最终执行」。超时是客户端主动放弃等待,不是服务端拒绝执行。客户端在 50ms 时挂断,服务端还在第 51ms 到第 80ms 之间干活,活干完了,结果发不回去,也没人收。于是客户端认定失败,业务却已经发生。

同一周还遇到时间对不齐的问题。两台机器用各自的本地时间戳判断「谁的数据更新」。一台快一点,另一台慢 120ms。合并逻辑比较时间戳,选大的,结果把后写的旧值覆盖了先写的新值。业务看到的是价格刚改又变回去,查两边日志却都显示写入成功。

跨机按本地时间戳比新旧:A 认为 1000,B 认为 940,选中 A 的 A-v1
真实发生顺序是 A 先写、B 后写,但因 B 的钟慢 120ms,B 的后写被当成更旧的一次,被覆盖

这两件事看着不相干,其实是同一个根:在分布式系统里,你看到的「成功、失败、新旧」都只是某一台机器的本地视角,没有任何一个视角天然等于事实。这篇就把这个根拆开,讲清楚网络和时钟到底不可靠在哪,以及工程上怎么把「不知道」变成可接受的结果。

超时不等于失败,它只是一个「不知道」

超时的本质是一次本地决策:调用方等够了,决定不再等。它可以发生在请求发出前、发出后、甚至在响应回来的路上。对调用方来说,这三段的结局完全不同,但表面都是「超时」两个字。

一次远程调用其实有三种结局:对方执行成功、对方执行失败、对方到底做没做你不知道。第三种最要命,因为它既不能说成功也不能说失败,而绝大多数业务代码只写了两个分支。于是「不知道」被硬塞进「失败」里,接着触发重试,重试又把一次「不知道」变成两次真实写入。

一次远程调用的三种结局
成功收到明确结果,可以推进
失败对方明确拒绝,可以回退
不知道超时、连接断、响应丢,最危险

真正成熟的调用方不是去消灭「不知道」,而是承认它一定存在,并让重试在这种状态下也是安全的。这一点后面讲幂等键时还会展开,这里先记住一句:只要调用跨了进程,就永远有第三种结局。

网络不可靠,不只是慢

很多人把网络问题理解成「慢一点」。实际上一根网线、一次路由抖动、一台交换机过载,能制造出四种完全不同的坏结果,而且它们经常同时出现。

丢包请求或响应在中途没了。表现为超时,但对方可能已经执行。
重复同一份数据被送达两次。上层若没去重,就会重复扣款、重复发货。
乱序后发先到。单条连接内 TCP 会保序,但多条连接、消息队列、异步回调都不保证。
分区两台机器彼此不通,但各自都还活着,都以为对方挂了。这是 CAP 讨论的起点。

「网络分区」值得单独说一句。它不是某一台机器坏,而是两组机器之间的链路断了,可每组内部通信正常。此时两边都能对外提供服务,也都会认为自己才是对的。你在其中一边看到的「对方不在线」,在另一边看来完全相反。后面讲选主和脑裂,本质上就是处理这种局面。

所以「TCP 是可靠的」这句话只在单条连接、且连接没断的前提下成立。连接一断,之前发出去但没被确认的数据就悬空了,可靠传输的保证到此为止。分布式系统要面对的是连接会断、会重建、会走不同路径,可靠性必须由应用层自己再补一层。

观察层面也要跟着调整。只看「接口平均耗时」几乎发现不了丢包和乱序,因为它们体现为偶发的长尾、连接频繁重建、同一业务号短时间出现多次。排查时更该看的是耗时的分位分布、连接建立次数、以及按业务号聚合的重复率。这三个指标比平均值更能说明网络是不是在捣乱。

重试会把一次不确定放大成多次写入

重试是分布式系统里最自然的动作:失败了再试一次。问题在于,分布式里的「失败」经常只是「没收到结果」,重试并不修复事实,只是又执行了一遍业务。

更糟的是重试会放大流量。30 个客户端各重试 3 次,故障瞬间就是 90 个请求打向同一台服务。如果这台服务本来就因为过载才超时,重试会让它更过载,形成正反馈,最后连恢复都恢复不了。这种现象在行业里叫重试风暴。

把重试做安全,至少要同时满足三个条件。第一,被重试的操作是幂等的,也就是执行一次和执行多次结果一样,或者带一个幂等键让对方能识别重复。第二,重试有次数上限和总时长上限,不能无限重试。第三,重试间隔要退避并加随机抖动,避免所有客户端在同一毫秒一起回流。

还有一个常被忽略的点:重试的总预算应该小于上游的超时。比如网关给客户端 2 秒,下游服务自己重试三次、每次 800ms,加起来 2.4 秒,网关早就断了,后面的重试全是白做,还占着连接。预算要一层层往下分,不能各算各的。

这里顺带把投递语义讲清楚。至多一次,指消息最多送一次,可能丢;至少一次,指不丢但可能重复;恰好一次,是业务最想要的结果,纯靠传输层做不到,只能靠「至少一次投递 + 消费端幂等去重」组合出来。所以看到有人声称「我们的队列保证恰好一次」,多半是在消费端做了去重,而不是网络真的不重复。

不带幂等键的重试写操作,等于主动制造重复数据。尤其是「创建订单」「扣库存」「发消息」这类有副作用的调用,宁可先不重试,也不要盲目重试。

时钟不可信,本地时间戳不能用来比新旧

每台机器都有自己的钟。这个钟可能因为晶振误差慢慢漂,也可能被 NTP 一次性校正,往前跳或往后跳几百毫秒。跨机器比较两个本地时间戳,等于拿两把没校准的尺子量同一段距离。

前面那组输出就是典型:A 的钟读到 1000,B 的钟读到 940,合并逻辑认为 1000 更新,于是保留 A 的版本。可真实顺序是 A 先写、B 后写,B 只是钟慢了 120ms。结果是「后写的被当成旧的覆盖掉」,数据悄悄回退,没有任何报错。

这直接否定了很多系统里默认的「最后写入获胜」策略。它看起来简单,实际上把正确性押在了所有机器的钟都对齐这个前提上,而这个前提在真实环境里经常不成立。机房、容器、虚拟机、跨地域,任何一处时间源出问题,判断就错。

可行的替代有两类。一类是不依赖物理时间的逻辑顺序:每次写入带一个单调递增的版本号,或者用逻辑时钟记录「谁在谁之后发生」。另一类是把时间只当作辅助信息,真正的冲突靠版本号、向量时钟或业务规则来解。物理时间可以用来展示、用来排序展示列表,但不该用来决定谁覆盖谁。

测量「耗时」和判断「谁更新」是两件事。耗时应该用单调时钟,它只往前走,不受系统时间校正影响;判断新旧则不该用任何单机时钟,而该用版本号或逻辑时钟。

部分失败:一个请求里有的成功有的失败

单机程序里,一个函数要么成功要么抛异常,边界很清楚。跨进程之后,一次业务动作往往由多个远程调用拼成,每个调用都可能独立地成功、失败或悬空,于是出现「一半成功一半失败」的中间态。库存扣了、订单没建;钱扣了、券没发。这类现象就是部分失败。

部分失败不会因为你不去想它就消失。它只会以「数据对不上」的形式在事后冒出来,而且往往隔了几个小时才被发现。下面这张表把常见现象、真实原因和第一步该查什么对齐,便于排障时少绕路。

现象真实原因第一步查什么
同一笔订单出现两条记录客户端超时后重试,服务端两次都执行了写入查入口是否带幂等键、服务端是否按幂等键去重
用户扣了钱但订单没生成支付成功、建单失败,两个调用没有统一的事务边界按业务流水号把支付与建单的记录串起来看
刚改的价格又变回旧值跨机用本地时间戳比新旧,时钟偏差导致误判查合并逻辑用的是时间戳还是版本号
接口偶发超时,服务端日志却显示成功超时是客户端放弃等待,服务端仍执行完成对齐客户端超时时间与服务端处理耗时分布
一次故障后流量越打越高各客户端同时重试,形成重试风暴查重试次数、退避策略与是否有随机抖动
消息明明发了,消费端说没收到发送方收到的是本地写入确认,不是对方消费确认查投递语义是至多一次还是至少一次
两地数据不一致,各自都显示正常网络分区,两边都在独立提供服务查跨机房链路状态与两边的写入来源
补偿脚本跑完,账还是不平补偿本身不幂等,重复执行又叠加了一笔查补偿是否有唯一业务号与执行记录

这张表里没有一条是「代码写错了」。它们全部来自分布式本身的不确定性:网络会断、会重、会乱,时钟会对不齐,一次业务会拆成多个独立失败点。把责任归到某个人写错,通常修不好,因为它明天会以另一种现象再出现。

工程上兜住部分失败,最实用的手段不是让每个调用都变成事务,而是「先记流水、再对账」。每次关键动作先落一条带业务号的状态记录,成功和失败都更新状态;再由一个定时任务按业务号把上下游对一遍,把缺的补上、多的冲掉。这套做法的好处是,任何一步悬空都能在账上留下痕迹,而不是靠人去猜。

参数怎么定:超时、重试、幂等键

落到配置上,超时不能按平均值设,要按真实耗时的长尾设。取 p99 再加一点余量,比「平均 20ms 就设 30ms」靠谱得多,因为触发超时的往往正是那 1% 的慢请求。同时要给整条调用链留出总预算,越往下游,单次超时越短。

# 调用链超时预算(示意)
gateway:
  client_deadline: 2000ms      # 给最终用户的总时长
order_api:
  timeout: 800ms               # 单次调用
  max_attempts: 2              # 最多两次,含首次
  backoff: 50ms
  jitter: 0..30ms              # 避免同时回流
  total_budget: 1200ms         # 重试总时长,不能超过上游
  idempotency_key: order_id    # 写操作必须带

# 幂等键在服务端的用法(伪代码)
fn handle(req):
  key = req.idempotency_key
  if key is empty: reject(400)
  if store.get(key) is done: return store.result(key)
  result = do_business(req)
  store.put(key, result, ttl=24h)
  return result

幂等键的选择也有讲究。它应该由业务唯一标识生成,比如订单号加操作类型,而不是随机 UUID。随机键每次重试都不一样,服务端根本认不出是同一笔。键的存储要能持久化到业务落库那一刻,否则服务重启后又认不出来,去重就失效了。

时钟侧没有「配置」可调,只有使用规范:计算耗时统一用单调时钟;跨机排序统一用版本号或逻辑时钟;如果业务真的依赖物理时间,就要接受「时钟偏差会让排序出错」这个前提,并在设计上留出容忍窗口,而不是假设钟永远准。

除了超时和重试,熔断和隔离也该一起配。当某个下游的错误率或慢请求比例超过阈值,就先停止调用它一段时间,让请求快速失败,给下游留出恢复窗口;同时给每个下游单独分连接池和线程池,避免一个慢依赖把整个进程的资源耗尽。这两件事解决的是「一个失败拖垮全部」,和超时解决的是不同层面的问题。

边界与代价

幂等不是免费的。每个写操作都要多存一份键和结果,还要考虑过期时间、存储成本、键冲突。键过期太早,重试窗口内认不出重复;过期太晚,存储膨胀。对账和清理也要额外做。所以低价值、可重算的操作不必都上幂等,只有会产生资金、库存、权益影响的操作才值得。

重试也不是越多越好。重试适合「瞬时故障」,比如一次丢包、一次连接重置。对「已经过载」或「对方明确拒绝」的场景,重试只会加重问题。判断标准是:这次失败是偶发的,还是系统性的。偶发才重试,系统性应该降级或熔断。

逻辑时钟有它的局限。版本号能解决「谁覆盖谁」,却解决不了「两个并发写到底该保留哪个」,那要靠业务规则或更复杂的合并策略。而且逻辑时钟要求所有写入路径都遵守同一套规则,一旦有旁路直接改库,整套顺序判断就失效了。

不要为了追求「强一致」把系统做成单点。把所有跨机判断都收回到一台机器,确实能绕开时钟和网络问题,但代价是这台机器成了瓶颈和单点。分布式约束的意义不是让你退回单机,而是让你在设计时明确知道哪里会不确定、愿意为哪部分不确定性付多少钱。

当天可以自验的五件事

  1. 找出一个「超时即判失败」的调用点,确认服务端在该超时之后是否仍会执行;把结论写进注释。
  2. 给一个写接口加上业务幂等键,用同一键连续调用两次,确认第二次返回与第一次一致且没有新增记录。
  3. 检查项目里所有「比较时间戳决定新旧」的代码,列出哪些是跨机比较,评估是否能换成版本号。
  4. 统计一次真实调用链上每一层的超时配置,加起来是否超过最外层给用户的总时长。
  5. 把重试策略改成「有限次数 + 退避 + 随机抖动」,在预发环境制造一次下游超时,观察流量是否被打成尖峰。

这些约束定下来之后,下一个问题自然就来了:既然网络会分区、副本之间可能互相看不见,那当分区发生时,到底该保可用还是保一致。下一篇《CAP 与一致性模型:到底在取舍什么》就把这个取舍摆到桌面上,用读写集合和 quorum 说明它到底在选什么。