429 限流下重试到底省了什么:本地跑 200 个任务,结果和我想的不一样

写这篇的起因很具体:之前整理接口报错对照时,我给 429 配了一段「指数退避加抖动」的重试代码,写完顺手标了句「只对可恢复错误重试」。后来有人问,这段代码到底省了多少次无效请求?我答不上来,因为从来没量过。于是决定在本地跑一遍,把数字摆出来。

本来以为这会是一篇五分钟就能收尾的验证:退避应该明显优于固定间隔,贴个对比表就完事。第一版结果出来的时候我盯着屏幕愣了一下——两种策略的 429 次数完全相同,都是 1080 次,退避只是多成功 10 个任务,却把整体耗时从 2500ms 拖到 6719ms。这不是「退避有用」,是「退避在这个场景下基本没用」。于是我又补了第三组实验,才把结论拼完整。

一、先把实验说清楚,不然数字没法解释

用 Python 3.13 写了个离散事件模拟,虚拟时钟推进,不发起真实网络请求也不 sleep 真实时间,所以 200 个任务几毫秒就跑完。之所以选模拟而不是真打某个 API,是因为真实环境里网络抖动、服务端限流算法、其他租户的流量都不可控,两组实验拿到的数据没法公平对比;模拟能把变量锁死,只改「重试策略」这一项。

服务端模型是固定窗口限流:每 1000ms 窗口最多放行 10 次请求,第 11 次起返回 429。客户端是 200 个任务,遇到 429 按各自策略等待后重试,最多 6 次,仍失败就放弃。三组分别是:

  • 固定间隔:每次等 500ms,200 个任务在 t=0 一起涌进去;
  • 指数退避加抖动:从 200ms 起按 2 的幂增长、上限 3200ms,每次再叠 0~120ms 随机抖动,同样 t=0 齐发;
  • 削峰队列:不在 t=0 齐发,改成每 100ms 放行 1 个任务(正好对上服务端每窗口 10 个的容量),只有真撞上 429 才用退避兜底。

随机种子固定为 42。我把脚本连跑三次做了 md5 比对,三次输出完全一致;换成种子 1 和 999 再跑,成功数仍是 40 对 30,说明下面这些差异不是抖动碰巧撞出来的。

二、三组真实输出

策略成功 / 失败总请求数429 次数无效请求占比全部完成耗时
固定间隔 500ms30 / 1701110108097%2500 ms
指数退避 200ms 起 + 抖动40 / 1601120108096%6719 ms
削峰队列 100ms/个 + 退避兜底200 / 020000%19900 ms

先看最扎眼的一列:前两组的 429 都是 1080 次,无效请求占比 97% 和 96%,几乎没差别。原因不难想明白——200 个任务在 t=0 齐发,服务端每个窗口只放 10 个,剩下 190 个无论等多久回来,面对的还是一个满窗口。退避加抖动把重试时刻错开了一些,但错开的幅度(最多 120ms,退避封顶 3200ms)远不足以让 190 个任务排进 6 次重试能覆盖的窗口里。多数任务从头到尾都在撞同一堵墙。

退避多救回的 10 个任务,是抖动恰好把某一批请求挪到了下一个窗口开头;代价是等待时间指数增长,整体完成时间从 2.5 秒变成 6.7 秒。如果只看「成功率」,会误以为退避赢了;把耗时一起摆出来,它其实是用 2.7 倍的时间换了 5 个百分点的成功率。这也是我第一版跑完没敢直接下结论的原因。

第三组才是分水岭:把发送速率按服务端容量压平之后,200 个任务全部成功,429 归零,总请求数从 1110 降到 200。代价是耗时 19900ms,比前两组都长。但这里的「长」是老实排队,不是反复撞墙,而且没有一次请求被白打。

三、所以退避到底解决什么

这三组数据把一件常被混在一起说的事拆开了:退避解决的是「多个客户端同时重试导致反复碰撞」,解决不了「发送速率超过服务端容量」。前者是同步惊群,抖动确实有用;后者是供需缺口,只能靠减少并发或排队。我这个实验里 200 个任务齐发属于后者,所以退避几乎失效。

这也解释了为什么各家 API 文档都要同时给两条建议:客户端退避加重试,和服务端返回的 Retry-After。如果只看前者,很容易在突发批量任务里写出「重试很规范、但 97% 请求都是废的」这种代码。我之前那段重试骨架就属于这一类——逻辑没错,放错场景了。

四、可复现脚本

完整脚本不长,核心是一个按虚拟时间排序的事件堆。贴出来是想让这组数字能被自己复跑,而不是只当个结论看:

import heapq, random, json

WINDOW_MS, CAPACITY, TASKS, MAX_RETRY, SEED = 1000, 10, 200, 6, 42

class Server:
    def __init__(self):
        self.win_start = 0; self.win_count = 0
        self.total_429 = 0; self.total_req = 0
    def handle(self, t):
        w = (t // WINDOW_MS) * WINDOW_MS
        if w != self.win_start:
            self.win_start = w; self.win_count = 0
        self.total_req += 1
        if self.win_count >= CAPACITY:
            self.total_429 += 1; return 429
        self.win_count += 1; return 200

def wait_fixed(a, rng):
    return 500

def wait_backoff(a, rng):
    return min(200 * (2 ** a), 3200) + rng.randint(0, 120)

def run(name, strategy, smooth=False, seed=SEED):
    rng = random.Random(seed); srv = Server(); events = []
    for i in range(TASKS):
        heapq.heappush(events, (i * 100 if smooth else 0, i, 0))
    ok = fail = 0; finished = []
    while events:
        t, tid, attempt = heapq.heappop(events)
        if srv.handle(t) == 200:
            ok += 1; finished.append(t); continue
        if attempt + 1 >= MAX_RETRY:
            fail += 1; finished.append(t); continue
        heapq.heappush(events, (t + strategy(attempt, rng), tid, attempt + 1))
    return {"策略": name, "成功": ok, "失败": fail,
            "总请求": srv.total_req, "429": srv.total_429,
            "耗时ms": max(finished)}

for name, fn, sm in [("固定间隔", wait_fixed, False),
                     ("指数退避+抖动", wait_backoff, False),
                     ("削峰队列+退避", wait_backoff, True)]:
    print(json.dumps(run(name, fn, sm), ensure_ascii=False))

想验证「抖动到底有没有用」,把 wait_backoff 里的 rng.randint(0, 120) 删掉再跑一次就行,成功数会掉下来。想看容量变化的影响,改 CAPACITY 和削峰组的 i * 100 步长,让两者重新对齐。

五、这组数字不能外推到哪些地方

必须把边界说清楚,否则容易得出错误结论。

  • 这是虚拟时钟模拟,不是真实压测。没有网络延迟、没有连接超时、没有服务端排队,真实环境里退避的收益和代价都会变形。
  • 服务端只用了固定窗口一种模型。令牌桶、滑动窗口、漏桶对突发流量的容忍度不同,换成允许一定 burst 的模型,齐发那两组的成功数会明显好看一些。
  • 19900ms 不代表削峰「更慢」就不好。前两组的 2.5 秒是「170 个任务已经放弃」的时间,不是全部完成的时间;把失败任务算进去,可比性本来就有限。
  • 6 次重试上限是我定的。放宽到 20 次,退避组最终也能把大部分任务做完,只是耗时更长、429 更多。

所以这篇能给出的不是「哪个策略最好」,而是一个判断顺序:先算自己的发送速率有没有超过对方容量,超了就先削峰;速率合规但仍有偶发碰撞,再上退避加抖动。顺序反了,重试写得再漂亮也是在批量制造 429。

六、落到自己的代码里

按这个结论,我改之前那段 429 处理时会动两处。一是在批量调用前加一层限速,按对方公布的 QPS 控制投放,而不是让定时任务把几百个请求一次性推出去;二是把重试保留为「兜底」而非「主策略」,同时读 Retry-After 决定等待时长,别只用自己的固定公式。至于单次的偶发 429,退避加抖动依然是对的做法,这点没有变。

还有一个附带收获:以后评价重试策略,别只看成功率,把「429 次数」和「全部完成耗时」一起记下来。这次要不是把三列并排看,我大概会带着「退避更有效」的印象把这段验证写完,那才是真的白跑。

相关阅读

接口侧的错误分类和六步排查写在大模型 API 报错对照:401 / 429 / 超时 / 超长一次排完里,那篇的第一版重试骨架正是这次拿来实测的对象;如果任务本身是多步流程,重试次数还要和步数上限一起算,见多步任务编排实战:让 Agent 一句话跑完一串操作;工具调用侧的参数与 id 问题在AI Agent 工具调用失败排查。这组模拟的完整脚本可从OpenClaw 搭建 Kimi 模型智能体保姆教程那条主线往下找相关实践。

相关推荐

评论(0)
发表评论
▾
安卓、IOS免费上传工具
推荐
安卓、IOS免费上传工具
拖拽上传 IPA 文件,自动解析 Bundle ID、版本号、签名信息、备案公钥等
了解详情 ›
广告