先看一个很难向客服解释的现场。某电商把库存服务做了双机房,华东和华南各有一套,两边都能读写,靠异步复制同步数据。大促当天,用户下单成功,订单页显示「已支付」,但仓库拣货时发现库存还是原来的数字,没有扣;另一个用户刷新商品页,看到还剩 10 件,第三次刷新变成 9 件,再换一个机房访问,又回到 8 件。

客服把三个截图发到技术群,问「到底还剩几件」。群里给了三种回答,有人说以华东为准,有人说等几分钟就好。都不算错,但都没回答用户真正关心的问题:我这一单,到底算不算数。

这类事故背后其实是三个不同的问题被混在一起:写成功了但别的机房读不到;两个机房各有一份不同的值;两个请求同时扣减,后写的把先写的覆盖了。它们对应不同的机制,也对应不同的补救方式。这篇把 CAP 说准,把一致性拆成谱系,算清 Quorum 保证了什么,最后落到跨城库存的取舍上。

说明:本篇不涉及具体产品的安装与命令,出现的副本数、延迟、超时都是按常见部署估算的量级,不是某次线上事故的精确监控值。

先把「不一致」拆成三种病

第一种是复制延迟。写请求落在华东的主副本,返回成功;华南的副本还没收到这次更新,用户从华南读,自然读到旧值。补的办法是读主副本、等复制位点、或者接受一个「读己之写」的会话粘性。

第二种是副本分叉。两个机房都接受了写,各自有一份值,谁也不认谁。等网络恢复,必须有规则决定谁赢:按时间戳、按版本号、按业务优先级,或者干脆把冲突抛给业务合并。这一步叫冲突解决,它决定的是「哪份数据活下来」,而不是「哪份数据是对的」。

第三种是丢更新。两个请求同时读到库存 100,各自扣 1 写成 99,两件商品只扣了一件。这不是复制的问题,是「读—改—写」这个动作本身没有原子性。加乐观锁、悲观锁,或把扣减做成一条原子语句,都能解决,但每种都有代价。

「最终一致」只描述前两种情况的收敛,不解决丢更新。两份副本最后都变成 99,看起来一致了,但少扣的那一件不会自己回来。

CAP 说的其实是一道分区时的选择题

CAP 常被念成「三者取其二」,这个念法漏掉了最重要的前提。C 是一致性,严格讲是线性一致:所有节点在任何时刻看到同一份数据,读到的都是最近一次写。A 是可用性:每个请求都能在有限时间内得到非错误响应。P 是分区容忍:网络断开时系统还能继续工作。

问题在于,P 不是你能选的。只要系统跨机器、跨机架、跨机房,网络故障总会发生。分区是网络的属性,不是数据库的配置项。所以真正的选择只发生在分区期间:是拒绝一部分请求、保住「不返回错数据」,还是继续接受读写、保住「每个请求都有响应」。

这也是为什么「CA 系统」在分布式语境里不存在:没有 P,就不是分布式系统。单机 MySQL 讨论 CAP 没有意义,因为它根本不会被网络分区切成两半。把 CAP 当选型打分表是最常见的误用。

分区时选 C(CP)

少数派机房拒绝写入,或者直接返回错误;多数派继续服务。用户看到的是「下单失败,请重试」,但不会看到「下单成功却没扣库存」。代价是分区期间一部分用户不可用,恢复后还要处理积压请求。库存、支付、账务、分布式锁、元数据配置通常选这一侧。

分区时选 A(AP)

每个机房都继续接受读写,返回成功,但可能返回旧值,也可能产生两份冲突数据。用户看到的是「页面还能打开,数字可能是旧的」,系统恢复后靠冲突解决收敛。商品浏览、点赞数、购物车、动态流通常选这一侧。

要注意,选 CP 不等于「永远强一致」,它只是分区时牺牲可用性;选 AP 也不等于「永远脏数据」,它只是在故障时接受分叉。

一致性不是开关,是一条谱系

工程上说的「强一致」和「最终一致」,中间有五六档,每档用户都能感知到差别;从上往下,要求越来越松,代价越来越小。

线性一致读写都像只有一台机器。下单后任何节点都查得到,库存从 10 扣到 9,谁查都是 9。代价是每次写都要等足够多副本确认,跨城时直接叠加往返时间。
顺序一致所有副本按同一个顺序应用写,但允许延迟。两个用户看到的评论顺序一致,只是都可能晚两秒;它保证顺序不相反,不保证立刻看到。
因果一致有因果关系的操作不能乱序。回复不能出现在被回复的帖子之前,删除不能出现在创建之前。没有因果关系的两条写,顺序随意。
读己之写自己刚提交的内容,自己下一次读一定读得到;别人可能还要等一会。实现上常靠会话粘性,把同一用户的读固定到同一副本,或者读主副本。
单调读同一个用户反复刷新,看到的数据不会倒退。先看到 10 条评论,下次不会变回 8 条。它挡的是「在多个副本之间来回切」造成的时间倒流。
最终一致停止写入之后,经过一段时间,所有副本会收敛到同一个值。这句话没有承诺「多久」,也没承诺收敛过程中用户看到什么,工程上的「最终」必须自己定义并监控。

举一个能感知的例子。用户在 App 里发了一条评论,立刻刷新:如果看不到自己的评论,是缺了「读己之写」;如果看到了,但过两秒又消失了,是缺了「单调读」;如果评论出现在它所回复的那条消息上面,是缺了「因果一致」;如果三个用户看到的评论顺序都不一样,是缺了「顺序一致」;如果过了一分钟才全部对齐,那它至少做到了最终一致。

Quorum 的算术:R+W>N 保证了什么

多副本系统里最常见的一套控制手段是 Quorum。设副本数 N,一次写要成功写入 W 个副本才返回成功,一次读要读取 R 个副本才返回结果。如果 R + W > N,那么读的集合和写的集合必然有交集——这是鸽巢原理,不需要假设任何时钟或顺序。

拿 N=3、W=2、R=2 走一遍:写请求写进副本 A 和 B,返回成功;读请求读副本 B 和 C。B 里是新值,所以读能拿到新值;如果读的是 A 和 C,A 里也有新值。只要写成功过,任何一次读的两个副本里至少有一个见过它。读的时候如果发现两个副本版本不同,协调者取版本较新的那个返回,并异步把旧副本修成新值,这就是 read repair。

Cassandra 把这件事做成每次请求的参数:ONE 等一个副本,QUORUM 等多数(RF=3 时是 2),ALL 等全部,LOCAL_QUORUM 只在本地机房凑多数,EACH_QUORUM 要求每个机房各自凑够多数。写用 QUORUM、读用 ONE 时,R+W=3,不大于 N,读到旧值的概率就回来了。

一次 Quorum 读的补救动作
读 R 个副本
比较版本取较新值
异步回写旧副本
后台反熵再对齐

写的时候如果某个副本不可达,协调者不会干等。它把这次写存成本地的一条 hint,等那个节点恢复再补发,这叫 hinted handoff。hint 有保留期限(Cassandra 默认 3 小时),超时就只能靠后台的反熵修复用 Merkle 树逐段比对;全量 repair 很重,通常按天或按周排期,所以这条路径上的「最终」可能是几小时到几天。

关键的一点:R+W>N 只保证「读能碰到写过的最新版本」,不保证线性一致。原因有四条,每一条都能单独让这个保证失效。

第一,你得有办法判断哪个版本更新。Cassandra 默认用单元格时间戳做「后写赢」(LWW),时间戳来自各节点的墙钟,机器之间差几十毫秒是常态;一旦回拨,旧写会带上更大的戳,覆盖新值,读到的「较新版本」其实是错的。

第二,并发写没有先后。两个客户端同时改同一个 key,Quorum 能保证两边都写成功,但不能保证谁赢;冲突解决规则一执行,总有一份被静默丢弃。业务如果没有版本号或合并逻辑,丢的那次更新就再也找不回来。

第三,读修复是异步的,本次读碰到新值,旧副本还在,下一次读仍可能碰到它;第四,跨机房常用 LOCAL_QUORUM,交集只在本地机房成立。

一次完整的走查:跨城双活的库存扣减

回到开头那个场景。商品 X 初始库存 100,华东、华南两个机房都接流量,各承担一半。要求是:不能超卖,尽量少卖,故障时用户体验不能崩。

方案 A:分布式锁加强一致读写。库存放到跨城三节点的协调服务里,每次下单抢锁、读库存、扣减、释放锁。四次跨城往返,每次 RTT 约 30ms,合计 120ms,下单 P99 从 40ms 抬到 180ms,锁服务成为瓶颈。

故障表现:锁的租约是 5 秒,业务处理一旦因为 GC 停顿或下游超时超过 5 秒,锁会自动释放,第二个请求进来同时扣减,超卖就发生了。更严重的是分区:协调服务凑不齐多数派时,谁都拿不到锁,下单全面失败。这是典型的 CP 选择。账准了,但大促时不可用的代价很难接受。

方案 B:本地扣减加异步同步,再靠对账兜底。把 100 件拆成华东 60、华南 40,各自用本地事务扣自己的池子,不跨城。下单延迟回到 12ms,任一边故障都不影响另一边。同步走 binlog 或消息队列,正常延迟 300ms,大促积压时到 5 秒;调拨靠定时任务,某一边低于安全水位就从另一边调,也要几十秒到几分钟。

这个方案不会超卖,因为两个池子物理隔离;但会「少卖」:华东 60 件三分钟卖完,华南还剩 25 件,调拨没跟上,用户看到华东售罄。若为了不分仓,两边共享同一个库存池,那就回到丢更新的问题:A、B 同时读到 100,各扣 1,最后都是 99,卖了两件只扣了一件。这种超卖只能靠对账事后发现。

「最终」到底有多长,要把四段时间分开算。正常复制延迟 300ms;消费积压时 5 秒,是大促要盯的指标;节点故障后 hinted handoff 最多补 3 小时,超过就等 repair,可能是第二天;对账任务每小时跑一次,T+1 还会做全量核对。把它们统统叫「最终一致」,等于把 300 毫秒和 24 小时说成同一件事,客服和产品都没法据此设计话术。

方案 C,也是很多团队最后真正采用的:单元化。把同一商品的流量固定路由到一个机房,写只落在这个机房的主副本,本地事务保证线性一致;另一个机房只做冷备或只读。这样既不需要跨城锁,也不需要在两地之间赌最终一致,代价是要做流量路由和机房切换。这里真正的结论是:一致性模型的选择,很多时候其实是流量路由的选择。你不可能既要两地都写、又要线性一致、还要低延迟,三者只能取两个。

现象、真实原因与第一步排查

现象真实原因第一步查什么
刚下的单,订单页查不到读请求被路由到还没收到复制的副本,或读走了从库确认读路径是否读主、会话是否粘在同一条复制链路,查复制延迟分位值
库存扣了两次,或者只扣了一次读—改—写没有原子性;并发写被 LWW 覆盖;重试没有幂等查该 key 的版本号与更新时间戳,核对请求是否带唯一业务键
接口超时,但服务端其实成功了客户端超时时间短于服务端处理时间;重试打到了同一个逻辑操作查幂等表和请求 ID 的落库记录,确认超时后是否有补偿查询
机房之间互相覆盖,数据来回跳分区期间两边都接受写,恢复后按时间戳合并,时钟不可信查分区时间窗内的双写记录、两边的时钟偏差与冲突解决日志
白天正常,大促时读到旧值批量提交、消息积压、跨城带宽打满,复制延迟从毫秒涨到秒级看复制延迟的 P99 而不只是均值,对照写入峰值与网络出口流量
对账每天差几笔,长期不平补偿任务漏跑、死信队列没人处理、repair 没在窗口内完成查对账任务水位、死信数量、最近一次 repair 的成功时间
锁没释放,或者锁提前失效业务超时导致锁租约到期,或 GC 停顿让续期没发出去看锁持有时间分布与续期间隔,确认 TTL 是否大于 P99 处理时间的数倍

边界与代价

最终一致把复杂度推给了业务。数据库不再保证「读到最新」,你就得自己处理幂等、补偿、对账和中间态:同一操作重试多次结果要一样,失败的那一步要能补,差异要能被发现,订单停在「已支付未扣减」时用户要看到什么。

支付、库存、账务这类不能赌。它们错了要赔钱,而且事后很难复原。这类场景要么用线性一致(本地事务、单元化、必要时跨城强同步),要么把「最终」压缩到秒级并用对账兜底;不能因为「大部分时候没问题」就假设它不会出问题。

强一致的代价是延迟和可用性。跨城强同步写,一次下单要多等一个 30ms 的往返,P99 直接抬一个档;分区时还得选择拒绝服务。这个代价是确定的、每天都在付的,而最终一致的代价是概率性的、出一次事故才付。

多数业务其实落在中间。不需要线性一致,但需要读己之写、单调读和幂等重试。先问用户能接受多旧的数,再问这个旧数会不会赔钱,答案通常就清楚了。

不要用「最终一致」当事故解释。用户问的是「我这单算不算」,不是「系统多久收敛」。上线前要把每个字段的「可接受陈旧时间」写出来,超时要有降级或提示,否则最终一致只是技术团队内部的说法。

小结

CAP 不是三选二,而是「分区发生时,你要可用还是要正确」。P 是网络的属性,没得选;CA 在分布式语境里不存在。选 CP 的用户看到失败,选 AP 的用户看到旧值,这两种体验要提前和产品、客服对齐。

一致性是一条谱系,不是开关。线性一致、顺序一致、因果一致、读己之写、单调读、最终一致,每一档都对应一种用户能感知的现象。Quorum 的 R+W>N 只保证读写集合有交集,它挡不住时钟回拨、并发冲突、异步修复和跨机房的 LOCAL_QUORUM。

《最终一致》里的「最终」,必须自己定义:复制延迟多少、积压多久、hint 保留多久、repair 多久跑一次、对账多久一轮。这四个数字写不出来,就等于没有承诺。

当天可以自己验证的练习:

  1. 用两个连接(两个终端或两个客户端)对同一行数据做「读—改—写」,中间加 1 秒等待,观察后写的那次是否覆盖前一次,亲手复现一次丢更新。
  2. 写一个 Python 小脚本,模拟 N=3 的副本,随机让 1 个节点不可用,分别用 W=1/R=1、W=2/R=2、W=3/R=1 跑一万次,统计读到旧值的比例。
  3. 给你负责的下单接口设计一个幂等键,写清楚重复请求第二次返回什么、超时后的补偿查询怎么查。
  4. 列出你系统里「能接受旧 5 分钟」和「一秒都不能旧」的字段各三个,再看它们现在是不是走了同一条读路径。
  5. 用 curl 或浏览器开发者工具测一次写请求的耗时,再 ping 一次跨机房地址,估算「多等一个跨城往返」会让 P99 变成多少。

下一篇讲选型与迁移:什么时候别换。机制讲到这里,容易产生一种错觉:既然最终一致、Quorum、LSM 都能解释清楚,那换个库也没什么大不了。真实项目里更常见的失败不是「不懂原理」,而是「原理都懂,但迁移过程没有回滚方案、业务约束没列全」。下一篇把选型和迁移当成一次工程决策来算账。