先讲一次真实的雪崩。某推荐服务的下游是用户画像接口,平时 P99 120 毫秒。一天下午,画像库的一条慢查询把 P99 拉到 2 秒,推荐服务调用超时。推荐服务的 HTTP 客户端配了「失败重试 3 次」,团队觉得这是提高可用性的好习惯。于是每个请求变成了 4 次调用,2000 QPS 瞬间变成 8000 QPS。画像接口的连接池先满,排队变长,本来 120 毫秒能返回的请求也开始超时;更多请求进入重试。十秒后,画像接口彻底不可用,推荐服务、首页、搜索依次报错。

事后复盘,最刺眼的一句话是:「重试本来是为了更稳,结果把整个系统重试死了。」这不是重试的错,是重试没有配合限流、超时预算和熔断,单独使用就变成了故障放大器。

这篇按三个防线讲:进门前限流,出门前想清楚重试,出问题时熔断止损。每一步都给能落地的判断标准和代价。

故障是怎么被放大的

先认出现象,才能选对工具。下面这张表里,前三条经常同时出现。

现象真实原因第一步查什么
下游超时后,整体 QPS 变成原来的三四倍上游对所有失败都重试,且没有并发上限看客户端重试配置与下游入口 QPS 曲线
扩到多实例后,限流完全失效限流计数器存在单机内存,每个实例各算各的确认限流状态在进程内还是共享存储里
同一秒内请求被放行两倍固定窗口在窗口交界处重置,两个窗口各放一批看限流算法的窗口边界处理
部分用户一直 429,其他人正常限流键用了 IP,NAT 或公司出口把大量用户合并看 429 请求的限流键分布,是否集中在少数值
下游恢复后,上游还在持续报错熔断打开后没有半开探测,或客户端连接池未释放看熔断状态机与连接池指标
重试次数都设了,故障时反而更糟重试没有退避和抖动,所有请求同时再次到达看重试时间间隔是否固定、是否集中在同一毫秒
一个慢接口拖垮整个服务所有接口共享连接池和线程池,没有隔离看线程池、连接池是否按依赖或接口分组

放大链条通常是这样:下游变慢,调用方超时,超时的请求被重试,重试增加并发,并发让下游更慢。如果没有一道「最多允许多少请求同时在途」的闸门,这个循环会自己加速。

限流放在哪一层

限流的位置决定了它能保护谁。放错层,等于在洪水下游修堤坝。

网关层按 IP、租户、路由做粗粒度限流。优点是统一、业务代码无感;缺点是拿不到用户身份,键的选择有限,精细规则要频繁改网关配置。
服务层按用户、接口、资源做细粒度限流。能读到业务身份,规则可以跟业务走;缺点是多实例时必须有共享状态,否则限额会按实例数翻倍。
依赖层针对数据库、缓存、第三方接口做并发限制。保护的是最容易被打挂的下游;缺点是每个依赖都要单独配,漏一个就留一个缺口。

三层不是三选一,而是按风险叠加。网关挡住明显异常流量,服务层挡住单个用户的滥用,依赖层挡住内部调用把下游打满。小系统先做依赖层最划算,因为下游通常最先挂。

限流被触发时,返回什么也要设计。只返回一个 429 和一句「请求过多」,客户端通常只会立刻重试,等于把限流绕过去。响应里带上 Retry-After,告诉对方多久以后再来;如果客户端是自己可控的,还可以按错误码区分「限流」和「故障」,前者不要重试,后者才考虑退避重试。对浏览器端,最好给一个可读的提示,而不是让用户看到空白页。

多实例限流有两种实现:集中式计数(Redis 令牌桶或滑动窗口),所有实例共享;或者按实例分摊限额,每个实例只放行总量除以实例数。前者准确但有网络开销和热点键问题,后者简单但实例数变化时要重新分配,且某台实例故障会让总限额变少。请求量不高的内部服务,按实例分摊就够;对外接口、按用户限额,建议集中式。

限流的键不要只写 IP。一个公司出口、一个运营商 NAT 后面可能有几千个用户,按 IP 限流会让整栋楼一起 429。至少组合成「IP + 用户 ID」,匿名请求再用 IP 兜底。

四种算法,差在边界

固定窗口最简单:每个时间窗口一个计数器,到点清零。问题是窗口交界:限制每分钟 100 次,第 59 秒来 100 个,第 61 秒又来 100 个,两秒内实际放行了 200 个。

滑动窗口记录过去一段时间的请求时间戳,边界更平滑,代价是要存很多时间戳,内存和计算都随请求量涨。实际工程里常用「滑动窗口计数」:把一分钟切成六个十秒桶,统计当前桶和前面几个桶的加权和,精度够用,内存可控。

令牌桶是另一个思路:桶里最多放 N 个令牌,按固定速率补充,请求来了取一个,取不到就拒绝。它允许短时突发(桶里攒着的令牌),但长期平均速率被补令牌的速度限制住。漏桶则相反,请求先进桶,桶以固定速率流出,超出容量就拒绝,输出更平滑但突发会被削平。

下面的数字是我在本机用 Node 跑出来的,同一批请求分别喂给固定窗口和令牌桶。场景一:1000 毫秒窗口限制 100 次,在第 999 毫秒来 100 个,第 1001 毫秒又来 100 个。

请求时间(毫秒): 100 个 @ 999ms, 100 个 @ 1001ms
固定窗口(每 1000ms 100 次): { passed: 200, rejected: 0 }
令牌桶(容量 100, 每秒补 100): { passed: 100, rejected: 100, left: 0.2 }

固定窗口把 200 个全放了,因为两次都落在不同窗口;令牌桶只放了 100 个,因为令牌在 2 毫秒里只补了 0.2 个。这就是窗口交界漏洞的实际影响。

场景二更贴近线上:每秒稳定 80 个请求,持续 3 秒,中间在 1.5 秒附近叠两次 50 个突发。

稳定 80/s + 两次 50 突发: {
  fixed: { passed: 260, rejected: 80 },
  bucket: { passed: 339, rejected: 1, left: 29.9 }
}

固定窗口拒了 80 个,因为 100 个突发全挤进同一个窗口,窗口额度被瞬间用光;令牌桶只拒了 1 个,因为平均速率 80 低于补充速率 100,桶里一直有余额,突发能消化。注意这不代表令牌桶永远更好:如果攻击者持续打到上限,两者都会拒;令牌桶的桶容量本身就是一个可被利用的突发窗口,容量设得越大,瞬时冲击越强。

选型建议:接口保护用令牌桶,容量按「下游能承受的瞬时并发」定;对外计费类接口用滑动窗口,边界更公平;内部简单限流用固定窗口也行,前提是能接受交界处的双倍放行。

令牌桶的容量和补充速率要分开想。补充速率决定长期平均吞吐,容量决定允许多大的瞬时突发。把容量设成「一秒的额度」,突发最多也就一秒的量;设成「一分钟的额度」,一个攒了很久的客户端可以瞬间打出平时一分钟的流量,下游可能直接被打穿。容量宁可小一点,突发被拒总比下游挂掉好。

重试:先问能不能重试,再问怎么重试

不是所有请求都能重试。GET、HEAD 这类幂等请求,重试通常安全;POST 创建订单、支付、扣库存,重试可能产生两笔订单。对写操作,要么让接口支持幂等键,要么干脆不自动重试,把决定交给用户或上游业务。

能重试的请求,也要满足三个条件:失败是瞬时错误(超时、连接重置、503),不是参数错误或 401;重试次数有上限;重试之间要退避,而且退避要带随机抖动。

为什么抖动必须加?假设一万个请求同时失败,重试间隔固定 100 毫秒,那么第 100 毫秒会同时到达一万个请求,第 300 毫秒再来一万个,第 700 毫秒再来一万个。下游刚缓过来又被同一波打回去。下面是我在本机跑的重试分布,统计每次重试落在哪个 50 毫秒窗口,总共 1 万个失败请求、每个重试 3 次。

固定退避 100/200/400ms: 总请求 30000, 峰值 10000 个/50ms
  前 10 个 50ms 窗口: [0, 0, 10000, 0, 0, 0, 10000, 0, 0, 0]
全抖动 0~100/0~200/0~400ms: 总请求 30000, 峰值 7091 个/50ms
  前 10 个 50ms 窗口: [5583, 7091, 2998, 3340, 2905, 1856, 1255, 1235, 1254, 1016]
等抖动 50/100/200ms + 0~同值随机: 总请求 30000, 峰值 10000 个/50ms
  前 10 个 50ms 窗口: [0, 10000, 0, 2515, 5070, 2415, 0, 206, 1272, 2310]

固定退避的三个尖峰非常整齐,每个尖峰就是一万个请求同时到达。全抖动把重试摊到多个窗口,峰值降到 7091,后面几波也明显变矮。等抖动(先等一半,再随机等另一半)峰值仍是 10000,因为第一批重试最早也要 50 毫秒,全部落在第二个窗口;它改善的是后续波次,对第一波没有帮助。

所以推荐全抖动:delay = random(0, min(cap, base * 2^attempt))。第一次可能几乎立刻重试,听起来危险,但它是随机分散的,整体到达率远低于固定间隔。上限 cap 防止指数增长到几分钟,通常设 30 秒以内。

还有一个常被忽略的约束:重试预算。给一次请求设总时间预算,比如 3 秒,包含所有重试;而不是每次尝试各给 3 秒。否则三层调用各重试三次,最坏耗时是 27 次尝试的时间,用户早就走了,连接也一直占着。

服务端返回 Retry-After 时,客户端要尊重它,而不是继续按自己的退避节奏打。很多重试风暴就是因为客户端无视服务端的「稍后再来」,在服务端已经明确说「两分钟后」时仍然每 100 毫秒重试一次。对写请求,还要确认服务端是否支持幂等键;不支持时,宁可把失败暴露给用户,也不要自动重试,重复扣款比一次失败更难收场。

熔断:不认识的下游,先断开

熔断器像一个开关,有三种状态。关闭状态正常放行,同时统计失败率;失败率超过阈值就打开,之后一段时间所有请求直接失败,不再打下游;过了冷却期进入半开,只放少量探测请求,成功就关闭,失败就重新打开。

熔断器的三个状态
关闭:正常调用并统计
打开:直接失败,保护下游
半开:少量探测
成功则关闭,失败则继续打开

阈值怎么定?不要拍脑袋写 50%。先看历史:下游正常时错误率多少、P99 多少、超时比例多少。阈值应该设在「正常波动之上、故障之下」,比如正常错误率 0.1%,阈值可以设 30% 到 50%;同时要求统计窗口内至少有几十个样本,避免一两个失败就误开。

熔断打开的代价是这部分功能直接不可用。所以要有降级:读接口返回缓存或默认值,写接口返回明确的「稍后重试」,而不是假装成功。降级逻辑要提前写好并演练,不能等熔断打开时才临时加。

熔断和重试要一起设计。熔断打开时,重试应该被直接拒绝,而不是继续打下游。很多实现把重试写在更外层,结果熔断器刚打开,外层还在重试,保护就失效了。

还有一层保护叫隔离舱。不同依赖用不同的线程池或连接池,一个慢依赖最多把自己的池占满,不会拖垮整个服务。比如用户画像、短信、推荐各用独立的池,画像变慢时,下单接口仍然能跑。隔离舱的代价是资源利用率下降,每个池都要留余量;但对核心链路,这点余量比整体雪崩便宜。

一套可落地的骨架

先看服务内令牌桶的最小实现。它用进程内 Map 存桶,适合单实例或按实例分摊限额;多实例要换成 Redis 的原子脚本。下面这段是限流的核心逻辑,和上面跑出的数字用的是同一套算法。

const buckets = new Map();

function allow(key, capacity = 100, refillPerSec = 100) {
  const now = Date.now();
  const b = buckets.get(key) || { tokens: capacity, last: now };
  b.tokens = Math.min(capacity, b.tokens + (now - b.last) * refillPerSec / 1000);
  b.last = now;
  if (b.tokens < 1) {
    buckets.set(key, b);
    return false;
  }
  b.tokens -= 1;
  buckets.set(key, b);
  return true;
}

app.use((req, res, next) => {
  const key = req.user ? "u:" + req.user.id : "ip:" + req.ip;
  if (!allow(key)) {
    res.set("Retry-After", "1");
    return res.status(429).json({ code: "RATE_LIMITED" });
  }
  next();
});

重试封装的关键是「只对可重试错误、带抖动、有总预算」。下面这段可以单独跑,也可以塞进任何 HTTP 客户端。

async function withRetry(fn, { retries = 3, base = 100, cap = 10000, budget = 3000 } = {}) {
  const started = Date.now();
  for (let attempt = 0; ; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const elapsed = Date.now() - started;
      if (attempt >= retries || !err.retryable || elapsed >= budget) throw err;
      const ceiling = Math.min(cap, base * 2 ** attempt);
      const delay = Math.floor(Math.random() * ceiling);
      await new Promise(r => setTimeout(r, delay));
    }
  }
}

熔断器的配置建议放进环境变量,按依赖分别配:BREAKER_ERROR_RATE=0.5、BREAKER_WINDOW_MS=10000、BREAKER_COOLDOWN_MS=30000。不要所有依赖共用一套阈值,数据库和短信网关的故障模式完全不同。

这些机制必须留下指标,否则等于没装。至少记录四类数:被限流的请求数与限流键、重试次数与最终失败数、熔断状态变化、每个依赖的 P99 与错误率。报警不要只看「错误率高」,还要看「重试率高」和「熔断打开」,后者往往比错误率更早出现,是故障的前兆。

验证方法:用 ab 或 wrk 对本地接口压 200 并发,观察 429 比例是否稳定在限额附近;把下游人为停掉,确认熔断在阈值内打开、请求快速失败而不是堆积;恢复下游后,确认半开放量探测、随后自动关闭。压测命令和 Kubernetes、网关配置这里只给示例,未在本机实测。

ab -n 10000 -c 200 "http://localhost:8080/v1/orders?limit=20"
kubectl patch configmap api-config --patch '{"data":{"RATE_LIMIT_PER_SEC":"200"}}'

边界与代价

限流不能修复慢查询。如果下游每个请求都要 2 秒,限流只能决定先拒绝谁,不能让它变快。限流是止血带,不是药。根因还要回到数据库、缓存和代码本身。

集中式限流会引入新的依赖。Redis 挂了,限流要么全放行(等于没有),要么全拒绝(等于故障)。要提前定好策略,并给 Redis 配高可用;多数团队低估了这条依赖的影响面。

热点键会让集中式限流失效。所有实例同时读写同一个用户的令牌桶,Redis 的那个 key 会成为热点,延迟升高,限流判断本身变成瓶颈。缓解办法是按实例预分桶、本地缓存加批量同步,或者对超热点用户单独做本地限流。没有一种方案是零成本的,关键是别把限流器本身变成故障源。

重试次数越多,尾延迟越长。三次重试能让成功率好看一点,但最坏耗时接近四次超时之和。对用户体验敏感的接口,可能宁可不重试,直接返回降级内容。

熔断阈值没有标准答案。定得太低会频繁误开,用户体验比故障还差;定得太高又起不到保护作用。它需要根据自己系统的历史数据调,不能照抄别人的配置。

过度设计的信号:系统只有两个实例、QPS 不到 50,却上了集中式限流、三级熔断、动态阈值调节。先把超时和连接池配好,往往就能解决八成问题。

当天可以自验的五件事

  1. 把服务的 HTTP 客户端重试配置翻出来,确认是否只对幂等请求重试、是否有抖动和总预算。
  2. 用本机 Node 跑一次文中的限流脚本,把突发请求喂给固定窗口和令牌桶,对比放行数量。
  3. 检查限流键:如果只有 IP,构造一个共享出口场景,看是否会误伤同网段的正常用户。
  4. 给一个下游接口人为制造 500,观察熔断是否在预期时间内打开、请求是否快速失败。
  5. 把一次请求的总超时预算写下来,核对各层超时之和是否超过它;超过就说明重试会把用户拖死。

下一篇讲消息队列与异步任务。限流和熔断解决的是「现在撑不住」,队列解决的是「现在不用马上做完」。但队列一旦引入,幂等、顺序、积压和重复消费的问题会一起到来,并不是把请求扔进去就完事。