令牌桶限流:使用令牌桶算法限流

问题:流量太大,系统扛不住怎么办?🚨

前面我们学会了用Redis和队列处理高并发,但还有个问题:这两招都要求请求先”进到系统里”。

Redis 原子扣减是为了让”已经进来的请求”处理得更快,消息队列是为了让”已经进来的请求”排得更有序。可是如果每秒有 50 万个请求同时涌到入口,这些请求在到达 Redis 之前、在网关、在风控、在线程池的每一次排队里就已经消耗掉了资源——队列排得再有序,队伍本身也长得看不到头。

更麻烦的是,这些请求是注定要失败的:库存只有 100 件,49.99 万个请求的结局都是”已售罄”。让它们全部穿过网关、读 Redis、查风控、查数据库,是拿整个系统的算力去买一个必然为假的答案。

所以还需要最后一道闸:在请求进入系统之前,就决定哪些请求根本没资格进来。这就是限流要解决的问题——它不提高单请求的处理能力,而是控制单位时间内进入系统的请求数量,把注定失败的流量挡在门外。

什么是限流?🛡️

限流(Rate Limiting)就是给系统入口装一道闸门:单位时间内只放行一定数量的请求,超出的部分被拒绝、降级,或者排队等待。

秒杀场景下这件事几乎是必做的,原因很直白:

库存 100 台,50 万人参与抢
  → 绝大多数请求注定失败
  → 但它们都要穿过网关、读 Redis、查风控、进队列
  → 无效请求消耗的资源,可能比成功的那 100 单多出几个数量级

限流保护的不是”成功率”,而是”有效资源的分配”。 既然 99.98% 的请求注定失败,就不该让它们挤占 Redis 和线程池。把它们挡在门外,本身就是一种性能优化。

限流和几个容易混淆的概念:

机制关注点触发条件秒杀里的典型位置
限流速率请求数超过阈值网关入口,按 QPS 卡
排队数量请求数超过并发处理能力秒杀服务前,把洪峰拉平(第 5.3 节)
熔断可用性下游依赖超时或错误率飙升调 MySQL、Kafka 失败时快速失败
降级功能资源不足或负载过高关掉推荐、评论、积分展示

四者不是并列的候选,而是同一条链路上不同位置的保护:

用户请求
   │  限流:挡住超出速率的部分(成本最低)
   ▼
网关
   │  排队:把剩下的请求排成稳定流
   ▼
秒杀服务
   │  熔断:数据库扛不住时快速失败,而不是拖死
   ▼
数据库

限流还有一层容易被忽略的意义:它决定了”公平”由什么来定义。 如果完全不限制,一个手速 20 毫秒的脚本就能吃掉全部库存;限流至少把竞争拉回到”在同一个速率下排队”。当然,真正的公平性还要靠答题门槛(第 5.2 节)和风控体系(第 7 章)来保证。

秒杀限流有三个特殊之处:

  1. 阈值要按”接近库存规模”来定,而不是”系统最大吞吐”来定。 系统能扛 10 万 QPS,不代表应该放 10 万 QPS 进来——库存只有 100 件,放进来 10 万个请求,只会让 Redis 和队列承受上千倍于必要值的压力。
  2. 必须允许一定突发。 真人点击天然是突发的(整点那一秒所有人同时点),完全平滑的限流反而会误伤真实用户。
  3. 限流和拒绝要配合友好提示。 返回”网络繁忙,请稍后重试”远好过一个 500。

令牌桶算法详解 🪙

限流算法有好几种:固定窗口计数器、滑动窗口、漏桶、令牌桶。秒杀场景最常用的是令牌桶——它天然允许一定突发,同时又能把长期平均速率钉死在阈值上。这一节先把原理讲清楚,再落到 Redis 上。

核心原理

想象一个容量固定的桶(容量 b),上方有一根水管,以恒定速率(每秒 r 个)往桶里滴令牌。每个请求要先从桶里拿走一个令牌才能通行:

  • 桶里有令牌 → 拿走一个,放行
  • 桶是空的 → 拿不到令牌,限流

两个参数决定了一切:

  • r(速率):稳态下每秒放行多少请求
  • b(容量):桶最多能攒多少令牌,也就是允许的突发量

举个具体的例子:

桶容量 b = 5,每秒生成 r = 2 个令牌

t=0s   桶是满的,5 个令牌
       ↓  突然来了 8 个请求
       →  放行 5 个(桶清空),限流 3 个

t=0~1s  水管又滴进 2 个令牌
t=1s   桶中 2 个令牌
       ↓  来了 3 个请求
       →  放行 2 个,限流 1 个

t=1~2s  又滴进 2 个
t=2s   桶中 2 个令牌——稳态下就是每秒放行 2 个

注意桶满了之后,多余的令牌会被丢弃。 这是令牌桶和漏桶的关键区别:漏桶严格匀速,令牌桶允许”攒额度”。对秒杀来说这个特性是刚需——真人就是在整点那一瞬间集中点击的。

令牌桶的五个特性,以及它们在秒杀里的意义:

特性说明秒杀里的意义
允许突发桶满时最多一次性放行 b 个真人点击本来是突发的,不容易被误伤
封顶长期均值长时间看放行速率收敛到 r防止持续打满下游
天然削峰突发流量被”缓存在桶里”削掉开售瞬间的尖峰
状态极小只需要记 tokens 和 last 两个数一个 Redis Hash 就能存下
无锁并发靠 Redis 单线程执行脚本保证原子高并发下不会多放行

和其他算法比一比:

算法允许突发实现复杂度状态量主要问题
固定窗口计数器否低1 个计数器窗口边界会双倍放行
滑动窗口部分中一批分桶计数内存随窗口增大
漏桶否(严格匀速)中一个队列不适合真人的突发行为
令牌桶是(最多 b 个)中2 个数值桶容量设错会误伤

固定窗口的边界问题值得单独看一眼,因为它是很多”限流没生效”的根因:

固定窗口:每分钟放行 1000 个

  59.9s 时刻 → 属于窗口 1,放行到第 1000 个
  60.0s 时刻 → 属于窗口 2,从第 1 个重新数
  → 实际 0.1 秒内放行了 2000 个,是预期值的 2 倍

所以秒杀场景选令牌桶:真人点击是突发型(需要允许突发),系统又必须扛住持续压测(需要封顶速率),而令牌桶的两个参数——QPS 和突发倍数——运营同学能直接理解和配置。

Redis实现令牌桶

状态很简单,一个 Hash 就够:

桶 key:  limit:{scope}          (如 limit:activity:10086)
类型:    Hash
字段:    tokens   当前剩余令牌数(浮点)
         last     上次补充令牌的时间戳(毫秒)
TTL:     活动结束后自动过期,避免 key 堆积

真正要写的是”补充令牌 + 判断 + 扣减”这三步。它们必须是一个原子操作,所以用 Lua:

-- token_bucket.lua
-- KEYS[1]: 桶 key
-- ARGV[1]: 速率 r,每秒生成的令牌数
-- ARGV[2]: 桶容量 b
-- ARGV[3]: 本次请求需要的令牌数,默认 1
-- 返回:1 = 放行,0 = 限流

-- 用 Redis 的 TIME 取统一时间源
-- 多机部署时各网关的本地时钟有几百毫秒漂移,客户端传时间会让令牌提前或延后生成
local t = redis.call('TIME')
local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)

local rate     = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local cost     = tonumber(ARGV[3])

local state = redis.call('HMGET', KEYS[1], 'tokens', 'last')
local tokens = tonumber(state[1])
local last   = tonumber(state[2])

-- 首次访问:初始化成满桶
if tokens == nil or last == nil then
  tokens = capacity
  last = now
end

-- 按经过的时间补充令牌,最多补到桶容量
local elapsed = now - last
if elapsed < 0 then elapsed = 0 end      -- 时钟回拨保护
tokens = math.min(capacity, tokens + elapsed / 1000.0 * rate)

local allowed = 0
if tokens >= cost then
  tokens = tokens - cost
  allowed = 1
end

redis.call('HMSET', KEYS[1], 'tokens', tokens, 'last', now)
redis.call('EXPIRE', KEYS[1], 3600)
return allowed

调用方:

import redis

r = redis.Redis(host='redis-master', port=6379)

TOKEN_BUCKET_LUA = """...(上面的脚本正文)"""

_sha = None

def _load():
    global _sha
    _sha = r.script_load(TOKEN_BUCKET_LUA)
    return _sha

def allow(scope: str, rate: int, capacity: int, cost: int = 1) -> bool:
    """令牌桶限流:返回 True 表示放行,False 表示被限流。"""
    key = f"limit:{scope}"
    try:
        return r.evalsha(_sha, 1, key, rate, capacity, cost) == 1
    except redis.exceptions.NoScriptError:
        # Redis 重启或 SCRIPT FLUSH 后 SHA 失效,重新加载一次
        _load()
        return r.evalsha(_sha, 1, key, rate, capacity, cost) == 1

几个实现上的要点,每一个都对应一类真实事故:

为什么必须用 Lua,不能用三条命令拼。 GET → 计算 → SET 三步不是原子的。两个并发请求可能同时读到 tokens = 1,都判断”够用”,都放行——实际放行了 2 个。Lua 脚本在 Redis 里是整体原子执行的,不会有第二个请求插进中间。

为什么用 Redis 的 TIME 而不是客户端传时间戳。 多机部署时各网关的本地时钟存在几百毫秒漂移,客户端传时间会导致某些节点的令牌提前生成、某些节点延后生成。TIME 返回的是 Redis 主节点的时间,所有节点看到的是同一份。

为什么用 EVALSHA 而不是 EVAL。 脚本体传输一次后就只传 SHA 值,省掉每次几 KB 的网络开销。代价是要处理 NoScriptError:Redis 重启或执行了 SCRIPT FLUSH 之后 SHA 会失效,重新 script_load 一次即可。

浮点精度。 tokens 是浮点数,长期累加会有微小误差。可以在活动开始前把桶重置一次,或者干脆用整数放大 1000 倍存储。

性能。 单次 EVALSHA 在 0.1 毫秒量级,Redis 单实例扛 10 万 QPS 没问题。而且 Lua 串行执行,天然不会有令牌超发。

多级限流策略 🛡️🛡️🛡️

单靠一个维度的限流很容易被绕过——换 IP 就绕过了 IP 限流,换账号就绕过了用户限流。所以实际系统是分层的:

层级限流维度典型阈值主要防住什么实现位置
CDN / WAFIP、地域、UA单 IP 每秒 20 次粗暴扫描、简单爬虫边缘节点
网关全局 QPS、活动 QPS活动 5 万 QPS整体流量超过系统能力网关
用户单账号、单设备1 分钟 3 次单账号批量重试网关 + Redis
接口单接口 QPS下单接口 2 万 QPS单一热点接口被打爆应用入口
库存进入预扣链路的总量略大于库存数无效请求进核心链路秒杀服务

原则是:越靠前拦截,成本越低。

CDN 层拦掉 90% 的垃圾流量    →  几乎零成本
网关层拦掉 9% 的超速请求    →  一次 Redis 往返
用户层拦掉 0.9% 的批量重试  →  一次 Redis 往返 + 一次风控计算
真正进到秒杀服务的,可能只剩 0.1%

每一层拦掉的请求,都不会再消耗后面几层的资源。

用户维度限流的例子:

def check_user_limit(user_id: str, product_id: str) -> bool:
    """同一用户对同一商品,1 分钟内最多请求 3 次下单接口。"""
    key = f"limit:user:{user_id}:{product_id}"
    count = r.incr(key)
    if count == 1:
        r.expire(key, 60)          # 第一次计数时设置窗口
    return count <= 3

这个实现用的是固定窗口计数器(incr + expire),简单直接。它在窗口边界有”双倍放行”的问题(前面讲过),但对”防单账号疯狂重试”这个场景够用了——正常用户不会卡在 59.9 秒和 60.1 秒各点一次。真要严格,就换成滑动窗口或者令牌桶。

多层限流要一起配置,不能只配一层。 常见的错误是只在网关配了一个全局 QPS,结果脚本把速率压到阈值以下就通过了——因为用户维度的 key 本来就没有配置,脚本的每个账号都在允许的范围内。


分布式限流 🌐

单机令牌桶很简单,多机就要回答一个问题:所有网关节点共享同一个桶,还是各自一个桶?

先说结论:活动级、全局桶用 Redis 共享;用户级、IP 级的小桶用本地缓存 + 定期补充。 这是成本和精度的折中,不是二选一。

方案一:Redis 共享桶(全局精确)

前面那段 Lua 脚本本身就已经是分布式实现——所有节点都 EVALSHA 同一个 key,Redis 单线程执行脚本保证原子性。分布式场景下要重点强调的是时间源:必须用 Redis 的 TIME,不能用客户端时间戳。多机部署时各网关的本地时钟有几百毫秒漂移,客户端传时间会让某些节点的令牌提前生成、某些节点延后生成,等于凭空造出一批额度,或者白白卡掉一批请求。TIME 返回的是 Redis 主节点的时间,所有节点看到的是同一份。

        网关 A           网关 B           网关 C
          │                │                │
          └────────┬───────┴────────┬───────┘
                   ▼                ▼
            limit:activity:10086  (同一个 key)
                   │
                   ▼
              Redis(主从 + 哨兵)

它的代价是每一次限流判定都要一次网络往返。 Redis 单实例扛 10 万 QPS 没问题,但要知道往返时间是 0.1~1 毫秒——在网关这种高 QPS 场景下,这是笔不小的开销。

关于时钟偏移和”单一真相源”的取舍:

时间源漂移影响代价适合
客户端时间戳各节点时钟漂移直接变成限流误差零成本单机
本机时间 + NTP漂移通常小于 50 毫秒零成本本地桶
Redis TIME漂移为零,所有节点同源一次网络往返全局桶

用 Redis TIME 换来的是”全局只有一个真相源”,代价是每个请求多一次 RTT。对活动级全局桶,这个代价必须付——它决定了 50 万用户面对的是同一个额度池,而不是各自为政的五万个池子。

方案二:本地缓存 + 定期补充(分布式近似)

用户级、IP 级的小桶不需要全局精确,用本地桶就够了:

每个网关节点本地维护一个 Map<user_id, TokenBucket>

首次出现某个 user_id:
  1. 向 Redis 领一批令牌(Lua 脚本,一次领 N 个)
  2. 存进本地 Map,expiresAt = now + N / rate
  3. 用完或过期再去领下一批

领批脚本(Redis 侧,仍然是全局原子):
  扣减 limit:user:{uid} 的令牌数,返回本次实际领到的数量

这样,限流判定的本地开销从一次网络往返降到了零。 代价是精度下降:

方案判定延迟全局精度适合的维度
每次都问 Redis1 次 RTT精确活动全局 QPS、IP 维度
本地批量领令牌0最多超发 N 个用户维度、接口维度
本地估算 + 定期校准0取决于校准周期粗粒度的保护

超发量是可控的:一批领 N 个令牌、N 个用户各超发 N 个,全局超发上界是 N 倍。所以批量大小不能太大——用户维度领 3~5 个就够,意味着全局最多超发 5 倍,团队要能接受这个量级。批量大小就是这个方案的”精度旋钮”。

什么时候不该上分布式限流。 如果系统只有一个节点,或者流量小到本地桶根本不会耗尽,加 Redis 纯粹是复杂度浪费。限流的复杂度要和它保护的资源匹配——用 Redis 去保护一个每天几百次请求的内部接口,是把简单问题复杂化。

另外三个分布式特有的坑:

  • Redis 主从切换会丢状态。 主节点切换时正在写的桶状态可能丢失,切换后的第一个请求会看到”满桶”,等于凭空多放了一批。秒杀场景可以接受,但应该在切换后主动把全局桶重置成满桶,避免两个节点各持一份满桶导致实际容量翻倍。
  • Redis 挂了不能全线拒绝。 限流组件是保护措施,不是业务依赖本身。Redis 不可用时的降级策略必须是”放行 + 打点告警”,而不是”全部拒绝”——否则一次 Redis 故障就让整场活动停摆。用哨兵做判断,配一个熔断器,超过阈值就降级放行。
  • 本地缓存会带来”配置不一致”的窗口。 某节点把限流阈值调小了,其他节点还在用旧值。阈值必须从配置中心统一拉取,并且给节点一个刷新周期,而不是各节点各改各的。

限流效果对比 ⚖️

四种算法的差别,用一个具体的秒杀场景就能看明白。

场景:库存 1000,限流阈值 5000 QPS,允许突发 10000(即 2 秒的量)。真实流量是尖峰型——开售瞬间 0.5 秒内到达 8 万请求,之后快速衰减。

算法突发处理精度状态量单实例内存实现成本分布式难度秒杀适用性
固定窗口❌ 不允许,窗口边界还会双倍放行低(误差可达 1 个窗口)1 个计数器几十字节最低,INCR + EXPIRE低⚠️ 只适合粗粒度保护
滑动窗口⚠️ 部分允许,取决于分桶粒度中(误差 ≤ 1 个桶)N 个分桶计数N × 几十字节中中✅ 适合”平滑限速”
漏桶❌ 严格匀速,完全不接受突发高(输出速率恒定)1 个队列与排队量成正比中高中❌ 会误伤真人的突发点击
令牌桶✅ 最多放行 b 个,之后回到 r高(长期均值精确到 r)2 个数值几十字节中(要写 Lua 保证原子)中(Lua 天然原子)✅✅ 秒杀首选

最容易出事的是固定窗口。 它的边界问题前面讲过:59.9 秒放行到第 1000 个,60.0 秒新窗口从第 1 个重新数,0.1 秒内实际放行了 2000 个。在秒杀里,这个”2 倍”恰好落在最需要精确的那一瞬间。

漏桶在秒杀里是错的选择。 漏桶严格匀速输出,意思是”每秒只能过 5000 个”,超出部分排队等待。听起来很稳,但它和真人行为直接冲突——真人就是在整点那一秒集中点击的,漏桶会把这些请求硬生生拖到几秒甚至几十秒之后,而库存往往在拖过去的路上就被抢完了。令牌桶允许”攒额度”,正好对上了”整点爆发 + 长期平稳”的流量形态。

滑动窗口精度足够,但状态量会随窗口增长。 1 分钟窗口切成 60 个 1 秒的桶,状态量就是 60 个计数器。窗口越长、粒度越细,内存和 Redis 键数越可怕。在需要严格平滑(比如给某个开放 API 定 QPS)的场景它值得,在秒杀入口这种”突发优先”的场景,它相对令牌桶没有优势。

令牌桶的精度其实是”有偏但可控”的:它保证的是长期平均速率精确等于 r,而不是任意 1 秒窗口内的瞬时速率都小于等于 r。桶容量 b 越大,瞬时速率越可能超过 r,但持续时间不会超过 b ÷ r 秒。换句话说,令牌桶允许你”透支”一小段时间,但不允许你”长期赖账”。 令牌桶的 b 就是这个”透支额度”的显式声明——把它设成你能承受的最大瞬时放大倍数,而不是随手写个 100。

最后一条经常被忽略:实现成本不只在代码,还在运维。

维度固定窗口滑动窗口漏桶令牌桶
需要 Lua 吗不需要需要(分桶计数要原子)需要需要
状态过期能自动清理吗✅ TTL⚠️ 每个桶都要 TTL❌ 队列要主动清理✅ 整个桶一个 TTL
配置参数个数1 个(阈值)2 个(阈值 + 窗口)2 个(速率 + 容量)2 个(速率 + 容量)
调参直观性高中高高(QPS + 突发倍数)

“整个状态一个 TTL、到期自动消失”这一条在秒杀里价值很高。 固定窗口和令牌桶都是”一个 key 一个 TTL”,活动结束后不需要任何清理任务;滑动窗口的一堆分桶要挨个设过期;漏桶的队列更是需要专门的后台任务去捞。运维复杂度也是实现成本的一部分。


实战配置建议 ⚙️

配置限流参数,最容易犯的错是”凭感觉设一个整数”。下面给的是可以直接拿去用的起点,以及每一层该怎么根据真实流量校准。

第一层:CDN / WAF

项建议起点依据
单 IP 请求频率20 次/秒正常用户的页面轮询 + 静态资源回源,20 次/秒已经宽松
静态资源全部走 CDN,缓存 1 小时商品图、JS、CSS 是刷带宽的主力
地域不按地域限速代理池大量集中在机房 IP 段,地域特征不可靠

校准方法:观察 CDN 回源 QPS 的 P99。如果 P99 明显低于阈值,说明这一层拦不住东西;如果正常用户有 1% 被拦,说明阈值偏紧。

第二层:网关(活动全局)

项建议起点依据
活动全局 QPS库存数 × 50库存 1000 → 5 万 QPS。留 50 倍余量给”抢到的人还要查订单”这类合法请求
突发倍数 b2~3 倍 r真人点击天然突发(整点那 1 秒),但 3 倍以上就失去限流意义了
单 IP5 次/秒比 CDN 层宽,因为同一个 IP 可能是出口 NAT 后的多人

校准方法:盯住 实际放行 QPS ÷ 库存数 这个比值。正常情况下它应该在 20~100 之间。长期低于 10,说明限流太紧、在浪费流量;长期高于 200,说明限流形同虚设,瓶颈会被打到 Redis 上。

第三层:用户维度

项建议起点依据
单账号下单尝试1 分钟 3 次真人失败后重试 1~2 次是常态,超过 3 次基本是脚本
单设备下单尝试1 分钟 5 次允许一个设备上有家庭成员共用
单账号限购1 件 / 活动业务规则不是技术规则,但要在限流层再校验一遍

校准方法:看被限流的真实用户比例和脚本穿透率两个指标。前者超过 1% 就该放宽阈值,或者改成滑动窗口减少边界误伤。

第四层:接口维度

项建议起点依据
下单接口 QPS全局 QPS 的 40%其余 60% 留给查询、验证码、下单重试
库存扣减 QPS库存数 × 10扣减比下单便宜,但 Redis 集群的极限就在这里
风控查询 QPS与下单同量级风险画像查询同样是 Redis 读

第五层:核心链路

项建议起点依据
进入库存预扣的总量库存数 × 3这是最后一道闸,超过这个数直接返回”已售罄”
排队队列长度上限库存数 × 20超过就快速失败,不再排了(第 5.3 节)

参数该怎么随真实流量调整? 靠下面这个闭环:

活动前:按上表取起点 → 用预估峰值做压测 → 压出瓶颈点
   ↓
活动中:实时观测 放行 QPS ÷ 库存数 / Redis 延迟 / 被限流比例 / 答题触发比例
   ↓
活动中调整(只在允许的范围内):
   · Redis 延迟上升     → 降低全局 QPS,而不是扩容 Redis
   · 被限流比例 > 1%    → 放宽用户维度阈值
   · 下单接口延迟 > 100ms → 提高库存层阈值,或提前进排队
   ↓
活动后:把这一场的实际曲线变成下一场的起点

三条调参纪律:

  1. 先调粗粒度,再调细粒度。 全局 QPS 错了,用户维度的阈值调得再准也没用。顺序是:CDN → 网关全局 → 接口 → 用户。
  2. 一次只改一个变量。 同时改两个阈值,事后归因不了是哪个起的作用,经验也沉淀不下来。
  3. 阈值必须可配置、可热更新,不能写死在代码里。 活动开始前 5 分钟能改一个参数,比活动开始后 5 分钟扩容 10 台机器更有效。配置化是限流系统最容易被省掉、也最不该省掉的一步。

最后提醒一句:限流阈值和”库存数”强耦合,库存一变,阈值就该跟着变。 1 万件库存和 100 件库存的秒杀,全局 QPS 应该差两个数量级。把参数写死在一个”标准值”上,是线上事故的常见来源。


想一想

问题 1:限流会不会影响用户体验?

提示:

  • 大部分用户会被限流拦截
  • 用户体验如何?
  • 如何让用户理解?
限流体验误伤提示设计

解题思路

“限流会不会影响体验”这个问题问错了方向——在秒杀里,被限流是绝大多数用户的默认结局,因为库存本来就只够千分之一的人。所以真正的问题不是”要不要限流”,而是”被限流的那一刻,用户看到什么、下一步能做什么”。

详细步骤

  1. 先接受一个事实:大部分用户注定抢不到。 库存 1000、报名 50 万,99.98% 的人会失败。限流的本质不是”让一部分人失败”,而是”让失败发生在便宜的地方”——挡在网关上,而不是让他读完全部详情页、查完风控、进了队列才失败。被限流的请求消耗的资源,可能比成功的那 100 单多出几个数量级。

  2. 限流有三种截然不同的结果,体验差别极大:

    • 直接拒绝:最省资源,但用户只看到”网络繁忙”,什么都不知道;
    • 排队等待:资源友好,但要给等待时长的预期(第 5.3 节);
    • 引导离开:最诚实,“已经抢完了,您先看看别的”。
  3. 提示语必须解释”为什么”,而不只是说”不行”。 差:“服务器繁忙”;好:“本次名额已抢完(共 1000 件),您可以设置到货提醒”。前者让用户觉得系统坏了,后者让用户理解规则。

  4. 要区分”限流”和”售罄”这两种完全不同的结果。 限流是”你来得太频繁了”,售罄是”货没了”。把限流提示成售罄会掩盖真实的容量问题;把售罄提示成限流会让用户反复重试,反而制造新的洪峰。

  5. 阈值要从”被限流的真实用户比例”反推,而不是从系统容量正推。 这条纪律很关键:系统扛 10 万 QPS 不代表应该放 10 万进来。库存只有 100 件,放进来 10 万个请求只是让 Redis 承受上千倍于必要值的压力。 建议把”被限流的真实用户比例”控制在 1% 以内(按第 5.1 节的分层配比推算)。

  6. 正常用户不该被误伤。 真人点击天然突发(整点那 1 秒),所以令牌桶必须允许突发,容量 b 取 23 倍速率;如果用固定窗口,边界会双倍放行;而用户维度”1 分钟 3 次”要允许真人失败后重试 12 次。

  7. 限流本身也要分级、被限流的用户要有升级路径。 多次被限流的用户可以收得更紧;偶尔被限流的老用户可以给一点额度。被限流是规则,不该是判决。

  8. 最后,“限流”和”公平”是两件事。 限流把竞争拉回”同一个速率下排队”,但真正的先到先得要靠排队号(第 5.3 节)和答题门槛(第 5.2 节)、风控体系(第 7 章)。用户能接受”我手慢了”,不能接受”系统在针对我”——所以提示的措辞要保证他知道自己是被规则挡住的,不是被随机抛弃的。

最终答案

会,而且在大规模秒杀里被限流是大多数用户的默认结局——因为库存本来就只够千分之一的人。限流的正确定位是”让失败发生在最便宜的地方”,而不是”让一部分人失败”。体验优化的关键是三件事:用限流/售罄/排队三种不同语义分别提示、说清规则让用户知道自己被规则挡住而非被随机抛弃、把”被限流的真实用户比例”控制在 1% 以内,并用令牌桶的突发容量避免误伤整点集中点击的真人。

问题 2:如何处理被限流的请求?

提示:

  • 直接返回错误?
  • 让用户排队?
  • 引导到其他页面?
限流处置快速失败降级

解题思路

被限流的请求必须尽快结束——它已经把系统拖到过载边缘了,继续占着连接和线程就是雪上加霜。所以处理的第一原则是”快速失败,且失败得体面”。但”快速失败”不等于”扔一个 500”。

详细步骤

  1. 先分级,再选处理方式。 不是所有超限请求都该得到同一种回应:

    限流层级处理方式理由
    CDN / WAF直接丢弃或返回静态页成本为零,值得最粗暴
    网关全局返回”活动火爆,请稍后重试” + 短冷却用户可能只是手慢,给一次机会
    用户维度排队或冷却明确是”你太频繁了”,不是”系统不行”
    库存 / 售罄返回”已售罄” + 替代商品再重试也没用
    核心链路快速失败 + 熔断保护下游保护的是整个系统的存活
  2. 不要返回一个裸的 5xx。 500 会让客户端以为系统坏了,从而触发重试风暴——流量越高越容易超时,越超时重试越多,这是典型的正反馈。要用 429(Too Many Requests)或带明确业务错误码的 200,并带上 Retry-After。

  3. 排队是”限流”和”削峰”之间的桥。 短队列(几秒内能放行完)能把用户的体验从”失败”变成”等待”,代价是占用连接。队列长度必须有上限,超过就直接拒绝——排队系统的容量控制见第 5.3 节。

  4. 给一个可以继续走的出口。 “已售罄”之后要给替代路径:相似商品、补货提醒、活动预告、其他正在进行的活动。一次失败之后立刻给一个下一步,比反复重试有价值得多,而且能把流失的用户留在站内。

  5. 冷却比拒绝更好。 拒绝是”你不行”,冷却是”你等 3 秒再来”。对于用户维度限流(防单账号疯狂重试),冷却 3~5 秒能挡住绝大多数误伤,同时让正常用户几乎无感。

  6. 一定要区分限流和故障。 限流是”预期内的、有意的”,返回友好提示并打点;故障是”非预期的”,应该触发告警和熔断,而不是伪装成”活动火爆”。把故障说成”火爆”会掩盖真实事故。

  7. 被限流的请求也要打点,而且要能分层归因。 至少记:哪一层拦的、命中的哪个 scope、当时的实时 QPS。没有这些数据,你既不知道阈值是不是设错了,也无法在事故后复盘。

  8. 最后,优先选”更便宜的拒绝”。 一条经验顺序:能返回静态错误页就别开线程,能在网关拒就别进应用,能排队就别直接拒绝。每往后挪一层,成本就翻一倍以上。

最终答案

按限流层级分级处置:CDN 层直接丢弃,网关层返回带 Retry-After 的友好提示并给短冷却,用户维度用冷却或短队列而不是直接拒绝,售罄要返回”已售罄”加替代商品出口,核心链路才快速失败并熔断保护下游。返回码要用 429 或明确的业务错误码而不是裸 5xx(否则会触发重试正反馈),被限流不等于系统故障要分开告警,并且所有被限流的请求都要分层打点,才能校准阈值和事后复盘。

问题 3:限流参数如何动态调整?

提示:

  • 根据系统负载调整
  • 根据时间调整
  • 根据用户等级调整
动态限流参数调优配置中心

解题思路

动态调整的难点不是”能不能改”,而是”改什么、什么时候改、改完怎么知道是对是错”。没有闭环的动态调整比固定参数更危险——它会在你不知道的时候,把限流调成了一个既不保护系统、又不放行流量的中间态。

详细步骤

  1. 参数必须先能改,再谈动态。 硬编码在代码里的阈值,动态调整就无从谈起。阈值要放在配置中心,所有网关节点统一拉取,变更走灰度发布。 这是第一步,也是最容易被跳过的一步。

  2. 按负载调整:调的是”全局 QPS”,不是所有阈值。 观察 Redis 延迟、秒杀服务 P99、线程池排队长度。Redis 延迟开始上升时,正确的动作是降低全局 QPS 或扩容 Redis,而不是放宽任何一层的其他阈值。让 Redis 慢下来再靠加机器扛,是把容量问题变成成本问题。

  3. 按时间调整:分时段配置,而不是运行时硬改。 秒杀流量在开售前 1 分钟、开始后 10 秒、活动结束后 1 小时是完全不同的形态。最稳的做法是提前把几个阶段的阈值配好,到点自动切换,而不是在活动进行中靠人去点按钮。

开售前 5 分钟  →  收紧到日常阈值的 30%(拦预热阶段的脚本探测)
开售瞬间 0~30s →  切到活动峰值阈值 + 3 倍突发容量
开售后 30s~5min →  逐步回落到日常阈值
售罄之后       →  直接只放行查询接口,下单接口按"已售罄"处理
  1. 按用户等级调整:只调额度,不调判定逻辑。 会员、已完成实名认证的用户可以给更高的额度,但判定规则不能因人而异——否则会出现”同一秒、同样行为,一部分人被限一部分人不限”,是投诉和公平性争议的来源。让额度可分等,让规则对所有人一致。

  2. 一定要有”自动降级”作为兜底。 人工调整在活动高峰期是不可靠的——没人有空看监控再点按钮。自动降级应该基于明确信号:Redis 延迟超过阈值持续 N 秒,或错误率超过 X%,自动把全局 QPS 下调一档并告警。人工调整是补充,自动降级是保命。

  3. 调整的粒度要粗、步长要小、频率要低。 一次别把 QPS 砍一半,先砍 20% 观察 30 秒。频繁、大幅度的调整会让监控数据无法解读,你也不知道是哪一个改动起了作用。

  4. 每次调整都要盯三个数,缺一不可:

    • 被限流的真实用户比例(超过 1% 要放宽);
    • 黄牛拦截率 / 脚本穿透率(掉下来要收紧);
    • 系统核心指标(Redis 延迟、下单接口 P99)。

    只看前两个会伤用户,只看第三个会伤业务。

  5. 每次调整都要留下记录:谁改的、为什么改、调了多少、事后效果如何。 这些记录是下一场活动的起点参数。限流参数是唯一真正只能从实战中学出来的东西。

  6. 最后要有硬边界。 无论怎么动态调整,总要有一个人工兜底的上限(比如”活动全局 QPS 无论如何不得超过 X”),并且这个上限对应的是压测验证过的系统容量。动态调整只能在安全区间内活动,不能突破那条线。

最终答案

顺序是:先把阈值放进配置中心并支持灰度热更新(否则谈不上动态),再按三层来调——按负载只调全局 QPS(Redis 延迟上升就降 QPS 或扩容 Redis,而不是放宽别的阈值)、按时间用提前配好的分阶段阈值到点自动切换、按用户等级只调额度不改判定逻辑。兜底上要有基于 Redis 延迟和错误率的自动降级,人工调整粒度粗、步长小、频率低,每次都同时盯被限流的真实用户比例、黄牛拦截率和系统核心指标,并把调整过程记录下来作为下一场的起点。

发现内容有问题?

告诉我们哪里需要改进。