令牌桶限流:使用令牌桶算法限流
前面我们学会了用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 章)来保证。
秒杀限流有三个特殊之处:
- 阈值要按”接近库存规模”来定,而不是”系统最大吞吐”来定。 系统能扛 10 万 QPS,不代表应该放 10 万 QPS 进来——库存只有 100 件,放进来 10 万个请求,只会让 Redis 和队列承受上千倍于必要值的压力。
- 必须允许一定突发。 真人点击天然是突发的(整点那一秒所有人同时点),完全平滑的限流反而会误伤真实用户。
- 限流和拒绝要配合友好提示。 返回”网络繁忙,请稍后重试”远好过一个 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 / WAF | IP、地域、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} 的令牌数,返回本次实际领到的数量
这样,限流判定的本地开销从一次网络往返降到了零。 代价是精度下降:
| 方案 | 判定延迟 | 全局精度 | 适合的维度 |
|---|---|---|---|
| 每次都问 Redis | 1 次 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 倍余量给”抢到的人还要查订单”这类合法请求 |
| 突发倍数 b | 2~3 倍 r | 真人点击天然突发(整点那 1 秒),但 3 倍以上就失去限流意义了 |
| 单 IP | 5 次/秒 | 比 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 → 提高库存层阈值,或提前进排队
↓
活动后:把这一场的实际曲线变成下一场的起点
三条调参纪律:
- 先调粗粒度,再调细粒度。 全局 QPS 错了,用户维度的阈值调得再准也没用。顺序是:CDN → 网关全局 → 接口 → 用户。
- 一次只改一个变量。 同时改两个阈值,事后归因不了是哪个起的作用,经验也沉淀不下来。
- 阈值必须可配置、可热更新,不能写死在代码里。 活动开始前 5 分钟能改一个参数,比活动开始后 5 分钟扩容 10 台机器更有效。配置化是限流系统最容易被省掉、也最不该省掉的一步。
最后提醒一句:限流阈值和”库存数”强耦合,库存一变,阈值就该跟着变。 1 万件库存和 100 件库存的秒杀,全局 QPS 应该差两个数量级。把参数写死在一个”标准值”上,是线上事故的常见来源。
问题 1:限流会不会影响用户体验?
提示:
- 大部分用户会被限流拦截
- 用户体验如何?
- 如何让用户理解?
解题思路
“限流会不会影响体验”这个问题问错了方向——在秒杀里,被限流是绝大多数用户的默认结局,因为库存本来就只够千分之一的人。所以真正的问题不是”要不要限流”,而是”被限流的那一刻,用户看到什么、下一步能做什么”。
详细步骤
-
先接受一个事实:大部分用户注定抢不到。 库存 1000、报名 50 万,99.98% 的人会失败。限流的本质不是”让一部分人失败”,而是”让失败发生在便宜的地方”——挡在网关上,而不是让他读完全部详情页、查完风控、进了队列才失败。被限流的请求消耗的资源,可能比成功的那 100 单多出几个数量级。
-
限流有三种截然不同的结果,体验差别极大:
- 直接拒绝:最省资源,但用户只看到”网络繁忙”,什么都不知道;
- 排队等待:资源友好,但要给等待时长的预期(第 5.3 节);
- 引导离开:最诚实,“已经抢完了,您先看看别的”。
-
提示语必须解释”为什么”,而不只是说”不行”。 差:“服务器繁忙”;好:“本次名额已抢完(共 1000 件),您可以设置到货提醒”。前者让用户觉得系统坏了,后者让用户理解规则。
-
要区分”限流”和”售罄”这两种完全不同的结果。 限流是”你来得太频繁了”,售罄是”货没了”。把限流提示成售罄会掩盖真实的容量问题;把售罄提示成限流会让用户反复重试,反而制造新的洪峰。
-
阈值要从”被限流的真实用户比例”反推,而不是从系统容量正推。 这条纪律很关键:系统扛 10 万 QPS 不代表应该放 10 万进来。库存只有 100 件,放进来 10 万个请求只是让 Redis 承受上千倍于必要值的压力。 建议把”被限流的真实用户比例”控制在 1% 以内(按第 5.1 节的分层配比推算)。
-
正常用户不该被误伤。 真人点击天然突发(整点那 1 秒),所以令牌桶必须允许突发,容量 b 取 2
3 倍速率;如果用固定窗口,边界会双倍放行;而用户维度”1 分钟 3 次”要允许真人失败后重试 12 次。 -
限流本身也要分级、被限流的用户要有升级路径。 多次被限流的用户可以收得更紧;偶尔被限流的老用户可以给一点额度。被限流是规则,不该是判决。
-
最后,“限流”和”公平”是两件事。 限流把竞争拉回”同一个速率下排队”,但真正的先到先得要靠排队号(第 5.3 节)和答题门槛(第 5.2 节)、风控体系(第 7 章)。用户能接受”我手慢了”,不能接受”系统在针对我”——所以提示的措辞要保证他知道自己是被规则挡住的,不是被随机抛弃的。
最终答案
会,而且在大规模秒杀里被限流是大多数用户的默认结局——因为库存本来就只够千分之一的人。限流的正确定位是”让失败发生在最便宜的地方”,而不是”让一部分人失败”。体验优化的关键是三件事:用限流/售罄/排队三种不同语义分别提示、说清规则让用户知道自己被规则挡住而非被随机抛弃、把”被限流的真实用户比例”控制在 1% 以内,并用令牌桶的突发容量避免误伤整点集中点击的真人。
问题 2:如何处理被限流的请求?
提示:
- 直接返回错误?
- 让用户排队?
- 引导到其他页面?
解题思路
被限流的请求必须尽快结束——它已经把系统拖到过载边缘了,继续占着连接和线程就是雪上加霜。所以处理的第一原则是”快速失败,且失败得体面”。但”快速失败”不等于”扔一个 500”。
详细步骤
-
先分级,再选处理方式。 不是所有超限请求都该得到同一种回应:
限流层级 处理方式 理由 CDN / WAF 直接丢弃或返回静态页 成本为零,值得最粗暴 网关全局 返回”活动火爆,请稍后重试” + 短冷却 用户可能只是手慢,给一次机会 用户维度 排队或冷却 明确是”你太频繁了”,不是”系统不行” 库存 / 售罄 返回”已售罄” + 替代商品 再重试也没用 核心链路 快速失败 + 熔断保护下游 保护的是整个系统的存活 -
不要返回一个裸的 5xx。 500 会让客户端以为系统坏了,从而触发重试风暴——流量越高越容易超时,越超时重试越多,这是典型的正反馈。要用 429(Too Many Requests)或带明确业务错误码的 200,并带上
Retry-After。 -
排队是”限流”和”削峰”之间的桥。 短队列(几秒内能放行完)能把用户的体验从”失败”变成”等待”,代价是占用连接。队列长度必须有上限,超过就直接拒绝——排队系统的容量控制见第 5.3 节。
-
给一个可以继续走的出口。 “已售罄”之后要给替代路径:相似商品、补货提醒、活动预告、其他正在进行的活动。一次失败之后立刻给一个下一步,比反复重试有价值得多,而且能把流失的用户留在站内。
-
冷却比拒绝更好。 拒绝是”你不行”,冷却是”你等 3 秒再来”。对于用户维度限流(防单账号疯狂重试),冷却 3~5 秒能挡住绝大多数误伤,同时让正常用户几乎无感。
-
一定要区分限流和故障。 限流是”预期内的、有意的”,返回友好提示并打点;故障是”非预期的”,应该触发告警和熔断,而不是伪装成”活动火爆”。把故障说成”火爆”会掩盖真实事故。
-
被限流的请求也要打点,而且要能分层归因。 至少记:哪一层拦的、命中的哪个 scope、当时的实时 QPS。没有这些数据,你既不知道阈值是不是设错了,也无法在事故后复盘。
-
最后,优先选”更便宜的拒绝”。 一条经验顺序:能返回静态错误页就别开线程,能在网关拒就别进应用,能排队就别直接拒绝。每往后挪一层,成本就翻一倍以上。
最终答案
按限流层级分级处置:CDN 层直接丢弃,网关层返回带 Retry-After 的友好提示并给短冷却,用户维度用冷却或短队列而不是直接拒绝,售罄要返回”已售罄”加替代商品出口,核心链路才快速失败并熔断保护下游。返回码要用 429 或明确的业务错误码而不是裸 5xx(否则会触发重试正反馈),被限流不等于系统故障要分开告警,并且所有被限流的请求都要分层打点,才能校准阈值和事后复盘。
问题 3:限流参数如何动态调整?
提示:
- 根据系统负载调整
- 根据时间调整
- 根据用户等级调整
解题思路
动态调整的难点不是”能不能改”,而是”改什么、什么时候改、改完怎么知道是对是错”。没有闭环的动态调整比固定参数更危险——它会在你不知道的时候,把限流调成了一个既不保护系统、又不放行流量的中间态。
详细步骤
-
参数必须先能改,再谈动态。 硬编码在代码里的阈值,动态调整就无从谈起。阈值要放在配置中心,所有网关节点统一拉取,变更走灰度发布。 这是第一步,也是最容易被跳过的一步。
-
按负载调整:调的是”全局 QPS”,不是所有阈值。 观察 Redis 延迟、秒杀服务 P99、线程池排队长度。Redis 延迟开始上升时,正确的动作是降低全局 QPS 或扩容 Redis,而不是放宽任何一层的其他阈值。让 Redis 慢下来再靠加机器扛,是把容量问题变成成本问题。
-
按时间调整:分时段配置,而不是运行时硬改。 秒杀流量在开售前 1 分钟、开始后 10 秒、活动结束后 1 小时是完全不同的形态。最稳的做法是提前把几个阶段的阈值配好,到点自动切换,而不是在活动进行中靠人去点按钮。
开售前 5 分钟 → 收紧到日常阈值的 30%(拦预热阶段的脚本探测)
开售瞬间 0~30s → 切到活动峰值阈值 + 3 倍突发容量
开售后 30s~5min → 逐步回落到日常阈值
售罄之后 → 直接只放行查询接口,下单接口按"已售罄"处理-
按用户等级调整:只调额度,不调判定逻辑。 会员、已完成实名认证的用户可以给更高的额度,但判定规则不能因人而异——否则会出现”同一秒、同样行为,一部分人被限一部分人不限”,是投诉和公平性争议的来源。让额度可分等,让规则对所有人一致。
-
一定要有”自动降级”作为兜底。 人工调整在活动高峰期是不可靠的——没人有空看监控再点按钮。自动降级应该基于明确信号:Redis 延迟超过阈值持续 N 秒,或错误率超过 X%,自动把全局 QPS 下调一档并告警。人工调整是补充,自动降级是保命。
-
调整的粒度要粗、步长要小、频率要低。 一次别把 QPS 砍一半,先砍 20% 观察 30 秒。频繁、大幅度的调整会让监控数据无法解读,你也不知道是哪一个改动起了作用。
-
每次调整都要盯三个数,缺一不可:
- 被限流的真实用户比例(超过 1% 要放宽);
- 黄牛拦截率 / 脚本穿透率(掉下来要收紧);
- 系统核心指标(Redis 延迟、下单接口 P99)。
只看前两个会伤用户,只看第三个会伤业务。
-
每次调整都要留下记录:谁改的、为什么改、调了多少、事后效果如何。 这些记录是下一场活动的起点参数。限流参数是唯一真正只能从实战中学出来的东西。
-
最后要有硬边界。 无论怎么动态调整,总要有一个人工兜底的上限(比如”活动全局 QPS 无论如何不得超过 X”),并且这个上限对应的是压测验证过的系统容量。动态调整只能在安全区间内活动,不能突破那条线。
最终答案
顺序是:先把阈值放进配置中心并支持灰度热更新(否则谈不上动态),再按三层来调——按负载只调全局 QPS(Redis 延迟上升就降 QPS 或扩容 Redis,而不是放宽别的阈值)、按时间用提前配好的分阶段阈值到点自动切换、按用户等级只调额度不改判定逻辑。兜底上要有基于 Redis 延迟和错误率的自动降级,人工调整粒度粗、步长小、频率低,每次都同时盯被限流的真实用户比例、黄牛拦截率和系统核心指标,并把调整过程记录下来作为下一场的起点。
发现内容有问题?
告诉我们哪里需要改进。
