排队系统:设计排队系统削峰
限流和答题之后,还有个关键问题:
50 万人参与,库存只有 100 件
↓
限流挡住 48 万(令牌桶)
↓
答题再挡住 1.5 万
↓
剩下 5,000 个请求,在同一秒内涌进秒杀接口
↓
秒杀接口 → Redis 扣库存 → 队列 → 消费者 → MySQL
这 5,000 个请求在 1 秒内到达,而第 4 章的队列按 2,000 QPS 的速度消化——它们会在队列里堆成一座小山,用户等好几秒才拿到结果。 更糟的情况是,如果限流阈值配得宽松一点,5 万个请求同时进来,队列会直接堆到上百万条。
所以限流之后还需要最后一道:排队。
先说清楚排队和限流的区别,这是很多人混淆的地方:
| 限流 | 排队 | |
|---|---|---|
| 对超出的请求 | 直接拒绝 | 让它等着 |
| 用户体验 | “请求过多,请稍后” | “您前面还有 3,271 人,预计等待 2 分钟” |
| 解决的问题 | 保护后端不被压垮 | 把瞬时洪峰摊平成稳定流量 |
| 公平性 | 不保证(谁先到谁进) | 强(先到先得) |
| 系统利用率 | 低(拒绝的用户白白流失) | 高(每个请求都有明确的去处) |
限流是门卫,排队是号贩。 门卫把人挡在门外,号贩给人发号——号还是排上了,只是要等。
排队系统要解决的是三个具体问题:
- 削峰:把 5 万个瞬时请求,转换成每分钟稳定放行 N 个的涓流,让下游永远只面对 N 的压力。
- 公平:先到先得,可预期、可解释。谁抢到谁没抢到,不能靠运气。
- 可解释:用户随时知道自己排在第几、还要等多久、会不会轮到自己。
第 1 章给秒杀系统定的目标里有一条叫”可解释”——排队系统是这一目标最直接的实现者。
用时间换公平
秒杀的本质矛盾是:供给(100 件)远小于需求(50 万人)。这个矛盾不可能被技术消除——无论系统多快,49 万 9 百 99 个人注定抢不到。
那技术能做什么?让”谁没抢到”这件事变得可预期,而不是随机的。
没有排队:
用户在 0.001 秒和 0.002 秒分别提交 → 谁先到谁赢
→ 结果取决于网络延迟和机器负载,用户无法预期 → 投诉的来源
有排队:
用户在 0.001 秒和 0.002 秒分别取号 → 1 号和 2 号
→ 放行时按号放 → 用户知道自己排第几,能提前判断值不值得等
→ 公平变成一个可以被解释的规则
排队的本质是把”竞争资源”变成”分配号”。 谁都不需要抢,只需要等自己的号。
三个要素
一个可用的排队系统必须回答三个问题:
| 要素 | 问题 | 对应的设计 |
|---|---|---|
| 位置 | 我排在第几? | 排队号(自增序列),用户与号一一绑定 |
| 速度 | 什么时候轮到我? | 放行速率(每秒放行 N 个名额) |
| 容量 | 排不下了怎么办? | 队列人数上限,超出直接拒绝 |
位置和速度决定体验,容量决定稳定性。 三者都定不下来,排队系统就只是一个”显示loading”。
三种落地形态
| 形态 | 用户流程 | 优点 | 缺点 |
|---|---|---|---|
| 排队页 | 点抢购 → 跳转排队页 → 拿到号 → 轮询 → 放行后自动下单 | 削峰最彻底,页面可承载运营信息 | 用户多一次跳转,体验成本高 |
| 原地排队 | 在活动页内显示排队条 | 体验连续,无需跳转 | 前端要处理”未放行时按钮置灰” |
| 批次放量 | 分批开抢,第一批没抢到等第二批 | 规则简单,天然公平 | 用户要等下一批,节奏感差 |
秒杀通常用”排队页 + 原地轮询”的组合:点抢购先跳排队页拿号,拿到号之后进入活动页原地轮询进度,避免用户频繁刷新页面(刷新会把流量放大好几倍)。
和上一节答题的关系
答题(第 5.2 节)和排队都是”延迟放行”,但作用完全不同:
答题:把 5 万个请求减少到 5,000 个 → 减量
排队:把 5,000 个请求摊到 5 分钟里释放 → 摊平
答题是筛子,排队是节流阀。 答题筛掉的是”行为不像人”的请求,排队摊平的是”数量太多”的请求。两者叠加:先答题减量,再排队摊平,最后才进入 4.3 节的异步下单链路。
用户点击"立即抢购"
│
▼
┌──────────────────────────────────┐
│ 排队入口(Redis,取号) │
│ · 判断是否已排队(幂等) │
│ · 判断队列是否已满 │
│ · 分配排队号 │
│ · 记录用户排队状态 │
└────────────────┬─────────────────┘
│ 排队号
▼
┌──────────────────────────────────┐
│ 排队等待页 │
│ · 轮询排队进度 │
│ · 展示预计等待时间 │
│ · 放行后自动进入秒杀 │
└────────────────┬─────────────────┘
│ GET /api/queue/status
▼
┌──────────────────────────────────┐
│ 放行器(按速率释放) │
│ · 令牌桶:每秒释放 N 个名额 │
│ · 按排队号顺序取人 │
│ · 发放一次性抢购令牌 │
└────────────────┬─────────────────┘
│ 放行信号 + 一次性令牌
▼
┌──────────────────────────────────┐
│ 秒杀接口(真正的下单) │
│ · 校验一次性令牌(取出即失效) │
│ · Redis Lua 扣库存 + 入队 │
│ · 返回"已受理,处理中" │
└──────────────────────────────────┘
组件职责
| 组件 | 职责 | 关键要求 |
|---|---|---|
| 取号服务 | 分配排队号、判断队列容量 | 必须原子、必须幂等(重复点击拿到同一个号) |
| 排队状态存储 | 保存”谁在排、排第几” | 存 Redis,用有序集合按排队号排序 |
| 放行器 | 按固定速率释放名额 | 速率必须平滑,不能一口气全放 |
| 进度查询接口 | 回答”还要等多久” | 要能被大量用户高频轮询,不能压垮数据库 |
| 一次性令牌 | 放行资格的凭证 | 只能用一次,有 TTL,用完即焚 |
Redis Key 设计
queue:seq:{activityId} 排队号自增序列(INCR)
queue:waiting:{activityId} 等待中的用户(ZSET,score = 排队号)
queue:cursor:{activityId} 已放行到的排队号(游标)
queue:count:{activityId} 当前排队人数(计数器)
queue:user:{activityId}:{userId} 用户的排队状态(是否已排队、排队号)
queue:ticket:{activityId}:{userId} 一次性放行令牌
排队号用 INCR 生成,Redis 的单线程保证它全局唯一且严格递增。 严格递增很重要——它是公平性的基础。
等待队列用 ZSET 而不是 List,因为 ZSET 能按排队号排序、按下标取区间、还能 O(log N) 删除某个成员。用 List 的话,“取出前 N 个并删除”这种操作会变成 O(N)。
所有 key 都用 {activityId} 做 hash tag,保证同一活动的多个 key 落在同一个 slot——取号脚本要同时操作序列、队列、计数器和用户状态,跨槽会直接报错。
第一步:取号
取号要同时做四件事:查重、查容量、分配号码、记录状态。必须在一个 Lua 脚本里完成,否则并发下会超发排队号。
-- join_queue.lua
-- KEYS[1]: 序列 key queue:seq:{1001}
-- KEYS[2]: 等待队列 key queue:waiting:{1001}
-- KEYS[3]: 计数器 key queue:count:{1001}
-- KEYS[4]: 用户状态 key queue:user:{1001}:9527
-- ARGV[1]: 用户 ID
-- ARGV[2]: 最大排队人数
-- ARGV[3]: 队列成员 TTL(秒)
-- 返回:排队号(>=1)/ -1 已在队列 / -2 队列已满
-- 已经排过队的,直接返回原排队号(重复点击、刷新页面都幂等)
local exist = redis.call('ZSCORE', KEYS[2], ARGV[1])
if exist then
return tonumber(exist)
end
-- 队列已满,直接拒绝
local count = tonumber(redis.call('GET', KEYS[3]) or '0')
if count >= tonumber(ARGV[2]) then
return -2
end
-- 分配排队号
local seq = redis.call('INCR', KEYS[1])
redis.call('ZADD', KEYS[2], seq, ARGV[1]) -- score = 排队号,天然 FIFO
redis.call('INCR', KEYS[3])
redis.call('SET', KEYS[4], seq, 'EX', ARGV[3])
redis.call('EXPIRE', KEYS[2], ARGV[3]) -- 防止僵尸成员堆积
return seq
调用方:
JOIN_QUEUE_SHA = r.script_load(JOIN_QUEUE_SCRIPT)
def join_queue(activity_id: str, user_id: str) -> dict:
seq = r.evalsha(
JOIN_QUEUE_SHA, 4,
f'queue:seq:{{{activity_id}}}',
f'queue:waiting:{{{activity_id}}}',
f'queue:count:{{{activity_id}}}',
f'queue:user:{{{activity_id}}}:{user_id}',
user_id,
MAX_QUEUE_SIZE, # 队列容量
QUEUE_TTL, # 排队成员 TTL
)
if seq >= 1:
return {'state': 'WAITING', 'ticket': seq}
if seq == -1:
return {'state': 'ALREADY_QUEUED'}
return {'state': 'QUEUE_FULL'}
幂等是这里的重点。 用户紧张时会连点按钮、刷新页面,如果每次点击都发一个新号,用户就会在队列里排好几次;最坏的情况是用户刷新一次就多占一个位置,队列被少数人塞满。
第二步:放行
放行器是一个后台任务,按固定速率从等待队列里取人:
RELEASE_LUA = """
-- KEYS[1]: 游标 key queue:cursor:{1001}
-- KEYS[2]: 等待队列 key queue:waiting:{1001}
-- ARGV[1]: 本批放行数量
local cursor = tonumber(redis.call('GET', KEYS[1]) or '0')
local limit = cursor + tonumber(ARGV[1])
local users = redis.call('ZRANGEBYSCORE', KEYS[2], '-inf', limit, 'WITHSCORES')
local ids = {}
for i = 1, #users, 2 do
ids[#ids + 1] = users[i]
redis.call('ZREM', KEYS[2], users[i])
end
redis.call('SET', KEYS[1], limit)
return ids
"""
def release_batch(activity_id: str, rate: int) -> list[str]:
ids = r.eval(
RELEASE_LUA, 2,
f'queue:cursor:{{{activity_id}}}',
f'queue:waiting:{{{activity_id}}}',
rate,
)
# 发放一次性放行令牌
for uid in ids:
r.set(f'queue:ticket:{{{activity_id}}}:{uid}', '1', ex=TICKET_TTL, nx=True)
return ids
放行器按固定节奏跑:
while True:
released = release_batch(activity_id, RATE_PER_SECOND)
time.sleep(1.0) # 每秒放行 RATE_PER_SECOND 个名额
放行速率必须恒定。 有人会想”队列里排了 3,000 人,一次性全放行让它们抢,反正库存就 100 件”——这样就退化成没有排队了,而且会在瞬间产生 3,000 个并发请求,正好把第 4 章好不容易削平的小山又堆回来。
放行速率的设定原则:它应该等于(或略大于)下游能承受的速率。秒杀库存是 100 件,那就没必要每秒放 2,000 个——每秒放 100 个就够了,因为库存本来就只有 100 件。
第三步:查进度
用户每隔几秒问一次”我还要等多久”。这个接口会被高频调用,必须轻:
def query_status(activity_id: str, user_id: str) -> dict:
# 已经放行了
if r.exists(f'queue:ticket:{{{activity_id}}}:{user_id}'):
return {'state': 'PASSED', 'position': 0, 'estimated_wait': 0}
score = r.zscore(f'queue:waiting:{{{activity_id}}}', user_id)
if score is None:
return {'state': 'NOT_QUEUED'}
cursor = int(r.get(f'queue:cursor:{{{activity_id}}}') or 0)
ahead = max(int(score) - cursor, 0) # 前面还剩多少人
rate = RELEASE_RATE
wait_seconds = int(ahead / rate) if rate > 0 else None
return {
'state': 'WAITING',
'position': ahead,
'estimated_wait': wait_seconds, # 秒
}
全程只读 Redis,不碰数据库。 5 万个用户每 3 秒轮询一次,就是每 3 秒 1.6 万 QPS 的查询——这个量级只有 Redis 扛得住,MySQL 一定会被拖垮。
第四步:校验放行令牌
真正下单时,必须校验用户手里的令牌:
def submit_order(activity_id: str, user_id: str, order_id: str) -> str:
ticket_key = f'queue:ticket:{{{activity_id}}}:{user_id}'
# 取出即失效:一次令牌只能用一次(Redis 6.2+ 用 GETDEL)
if not r.getdel(ticket_key):
return 'TOKEN_INVALID'
# 拿到资格之后,剩下的交给 4.3 节的异步下单链路
code = try_buy(activity_id, product_id, user_id, order_id)
return {1: 'QUEUED', 0: 'SOLD_OUT', -1: 'DUPLICATE'}.get(code, 'ERROR')
令牌必须一次性。 如果放行后用户可以反复用同一个令牌下单,排队就形同虚设——第一秒放行 100 个人,他们可以同时发 1 万个请求。
令牌还要有 TTL(比如 30 秒):放行后用户去填个验证码就超时了,这部分人不该占用名额。
参数怎么定
| 参数 | 作用 | 设定依据 |
|---|---|---|
| 放行速率 | 每秒放行多少人 | 下游能承受的速率;秒杀场景下常设成略大于库存数 |
| 队列容量 | 最多容纳多少人排队 | 预期人数 × 冗余系数;超出直接拒绝 |
| 令牌 TTL | 放行资格的有效期 | 用户完成下单所需的时间(30 秒左右) |
| 排队超时 | 排多久自动退出 | 用户的耐心上限(通常 5-10 分钟) |
| 轮询间隔 | 用户多久查一次进度 | 递增间隔,2-5 秒起步 |
| 队列成员 TTL | 防止僵尸成员堆积 | 排队超时时间 + 缓冲 |
所有参数都要能从活动配置里改,不能写死在代码里——不同商品的热度差几个数量级,一套参数不可能通吃。
排队页不只是”显示一个 loading”,它承担着解释系统行为的职责。
页面元素
┌──────────────────────────────────────┐
│ │
│ 🔥 正在抢购中 │
│ │
│ 您的排队号:No. 12847 │
│ 前面还有约 3,271 人 │
│ 预计等待:约 2 分钟 │
│ │
│ ████████░░░░░░░░░░░░ 42% │
│ │
│ 请勿关闭页面,到达后会自动进入 │
│ │
│ [ 离开排队 ] │
└──────────────────────────────────────┘
| 元素 | 为什么要有 | 注意事项 |
|---|---|---|
| 排队号 | 让用户感到”我有位置”,而不是”我在干等” | 不要显示 499876 这种大数字,容易劝退 |
| 前面还有多少人 | 提供确定感 | 取整到百位即可,太精确反而失真 |
| 预计等待时间 | 让用户判断值不值得等 | 用区间(“约 2 分钟”)比精确值更诚实 |
| 进度条 | 视觉反馈,减少焦虑 | 进度按剩余位置算,不要用假进度 |
| 离开排队按钮 | 给用户退出权,避免”被困住”的怨气 | 释放位置要谨慎,见下文 |
| 自动跳转提示 | 说明页面不会白等 | 明确”到号后自动进入” |
状态机
┌──────────┐
│ 未排队 │
└────┬─────┘
│ 点击抢购
▼
┌──────────┐ 队列已满 ┌────────────┐
│ 排队中 ├───────────▶│ 排队已满 │
└────┬─────┘ └────────────┘
│ 轮询到号
▼
┌──────────┐
│ 已放行 │──▶ 自动跳转秒杀接口
└────┬─────┘
│ 下单结果
▼
┌────────┴─────────┐
▼ ▼
┌─────────┐ ┌─────────┐
│ 抢购成功 │ │ 抢购失败 │
└─────────┘ └─────────┘
状态必须可见、可区分。 用户最怕的不是失败,而是”不知道发生了什么”。第 1 章说的”可解释”,就落在这张状态表上。
轮询策略
不要固定高频轮询:
第 1 次:1 秒后
第 2 次:2 秒后
第 3 次:4 秒后
第 4 次:8 秒后
之后:每 10 秒一次
递增间隔既减少了服务端压力,也让用户不至于盯着屏幕刷。5 万用户固定 1 秒轮询是 5 万 QPS,递增之后平均下来不到 1 万 QPS。
更省事但体验更好的做法是长轮询:客户端发起一个请求,服务端挂住直到放行或超时(30 秒)才返回。前端只需在超时后重发,服务端压力接近于零。
文案设计
| 状态 | 文案 | 要点 |
|---|---|---|
| 排队中 | “您前面还有约 3,271 人,预计等待 2 分钟” | 给数字,也给时间 |
| 即将放行 | “您的排队号即将到达,请保持页面打开” | 提前预警,避免错过 |
| 已放行 | “正在进入抢购…” | 极短的过渡态 |
| 排队已满 | “当前排队人数已满,请稍后再试” | 明确拒绝,不让用户干等 |
| 排队超时 | “等待时间过长,本次排队已结束,请重新参与” | 解释为什么,同时给下一步 |
| 抢购失败 | “手慢了,商品已抢完” | 归因到用户能理解的原因 |
| 系统繁忙 | “系统繁忙,请稍后重试” | 给出重试建议 |
“手慢了”和”系统繁忙”对用户的情绪影响完全不同。 前者用户接受,后者用户愤怒——即使实际上是系统问题,也要先归因到用户能理解的事情上,同时在服务端记录真实原因。
前后对比
以 50 万人抢 100 件为例:
| 指标 | 无排队 | 有排队 |
|---|---|---|
| 到达秒杀接口的瞬时峰值 | 5,000-50,000 QPS | 放行速率(如 200 QPS) |
| 队列峰值长度 | 数十万条 | 等于”等待人数 - 放行速率 × 时间” |
| 下游(Redis 扣减 + 入队)负载 | 随洪峰剧烈波动 | 恒定 |
| MySQL 侧压力 | 随洪峰波动 | 恒定 |
| 用户可预期性 | 低(不知道什么时候轮到) | 高(明确知道位置和等待时间) |
| 系统可用性 | 差(洪峰一来就抖) | 好(压力恒定) |
一个算例
活动:库存 100 件,预期 50 万人参与
阶段 1 限流:50 万 → 2 万(令牌桶,5 万 QPS 上限)
阶段 2 答题:2 万 → 5,000(90% 的请求被判定为脚本)
阶段 3 排队:5,000 人在队列里等待,按 200 人/秒放行
排队峰值:
取号瞬间队列长度 = 5,000
消化时间 = 5,000 ÷ 200 = 25 秒
期间每秒放行 200 人进入秒杀接口
下游看到的样子:
Redis 扣减 + 入队:恒定 200 QPS
队列长度:5,000 → 4,800 → 4,600 → ... → 0
“5,000”和”50,000”的差别,就是排队系统的全部价值。 前者下游压力恒定、用户体验可预期;后者下游被冲击、用户被拖慢、系统被拖垮。
队列内存也要算
排队队列的内存 ≈ 排队人数 × 每条成员大小
5,000 人 × 约 100 字节 = 500 KB
50 万人排队(极端情况)× 100 字节 = 50 MB
和 4.2 节的订单队列不同,排队队列的消息量小得多(一个用户 ID 加一个分数),所以内存压力有限。真正的风险不在内存,而在取号和查进度的 QPS——这才是要重点压测的部分。
和第 4 章的呼应
排队的削峰效果,最终会体现在第 4.2 节那个”削峰填谷”的图上:
无排队:
入口 5 万 QPS 的尖峰 → 订单队列瞬间堆 20 万条 → 用户等 100 秒
有排队:
入口 200 QPS 的平流 → 订单队列几乎不积压 → 用户等 25 秒(等放行)+ 秒级(等落库)
两个队列是串联的缓冲。 排队队列在最前面把洪峰摊平,订单队列在最后面把数据库写压力摊平。
排队系统自己也会出问题。下面这些场景每一个都需要明确的处理动作:
| 场景 | 原因 | 用户看到 | 系统做什么 |
|---|---|---|---|
| 排队超时 | 等太久,用户耐心耗尽 | “等待时间过长,本次排队已结束” | 从等待队列移除,释放位置 |
| 队列已满 | 人数超过容量 | “当前排队人数已满,请稍后再试” | 拒绝取号,不进入队列 |
| 放行后下单失败 | 放行了但库存已被抢完 | “手慢了,商品已抢完” | 令牌作废,不重复放行名额 |
| 用户主动离开 | 点击”离开排队” | 回到活动页 | 移除等待队列成员,释放位置 |
| 页面刷新 | 客户端重连 | 无感 | 取号接口幂等,返回原排队号 |
| 活动提前结束 | 运营手动结束 | “本次活动已结束” | 清空队列,通知所有等待用户 |
| Redis 不可用 | 基础设施故障 | “系统繁忙,请稍后重试” | 降级:直接拒绝,而不是放行 |
| 放行器进程挂了 | 后台任务异常 | 排队人数不下降 | 监控告警 + 自动重启,队列本身不丢 |
三个容易做错的地方
1. 用户离开时,位置要还回去
用户离开后,他前面的号就空出来了。放行是按”排队号 ≤ 游标”来取的,所以空出来的号不会浪费——放行节奏是按人数算的,不是按号的大小算的,中间跳过几个号完全没问题。这一点很多实现会搞错,导致放行速率随离开人数下降。
2. 刷新页面必须拿到同一个号
取号接口的幂等靠的是 ZSET 里”用户 ID 已经存在就返回原号”。这一条在第 5.2 节的防刷里也有体现——排队号和用户绑定、一次性使用、不能靠刷新获得新号,这是防作弊的基础。
3. Redis 挂掉时不要放行
降级策略要选”拒绝”而不是”放行”:
✅ 降级为直接拒绝 + 提示"系统繁忙"
→ 少卖几单,但系统可控
❌ 降级为无令牌直接放行
→ 50 万请求瞬间打进来,前面所有的限流、排队、防刷全部失效
“拿不到排队系统”时,宁可少做一单,也不要把闸门打开。
问题 1:如何让排队更公平?
提示:
- 随机分配?
- VIP优先?
- 随机排队号?
解题思路
先分清两种”公平”:机会公平(每个人都有平等的机会参与)和结果公平(先到的人优先)。秒杀业务真正要的是后者——先到先得,因为商品是限量的,先到先得是用户最能接受、也最容易解释的规则。
详细步骤
-
排队号必须由服务端生成,且严格递增。用 Redis 的
INCR分配号,天然满足唯一性和顺序性。绝不能由客户端生成或随机分配——随机号会让”早到的人反而排在后面”,直接违背直觉。 -
先到先得是默认规则。用户点击”立即抢购”的那一刻分配号码,号码大小就是顺序。
-
把”点击时间”和”取号时间”区分开。用户 0 时刻点了按钮,但网络抖动导致 0.3 秒才到服务端,取到的是第 12847 号而不是第 1 号。这不是系统的问题,是网络延迟,但可以通过前端预取号来改善:在活动开始前 5 秒就允许用户”预排队”,页面加载时就拿到号,开抢瞬间直接用这个号下单。
-
VIP 优先要谨慎。给会员更高优先级在商业上常见,但在秒杀上极其敏感——“花钱就能插队”很容易引发舆情。如果要做,规则必须公开、明确、可预期(页面上写清楚”会员优先 30 秒”),而不是偷偷给。
-
真正的公平来自”规则透明”而不是”算法精巧”。一个所有人都能理解的规则(先到先得),比一个没人说得清的”智能排队算法”更公平,也更抗投诉。
-
配套防作弊:排队号与用户 ID 绑定、一次性使用、同一设备/账号只能取一个号。这些在第 7 章的反作弊里有更完整的方案。
最终答案
用服务端 INCR 生成的严格递增排队号实现先到先得,规则对所有用户公开透明;配合前端预取号减少网络抖动带来的不公平;VIP 优先如果要做就必须明示,绝不暗箱操作。公平的本质是”可预期的规则”,不是”复杂的算法”。
问题 2:排队用户太多怎么办?
提示:
- 队列长度限制?
- 预先告知排队人数?
- 分批排队?
解题思路
“排队用户太多”要分两种情况:排队人数超过容量(队列装不下)和等待时间超过用户耐心(队列装得下但排太久)。两种问题的解法完全不同。
详细步骤
-
超过容量:设上限并快速拒绝。取号时检查当前人数,超过上限直接返回”队列已满”。上限要留出余量,并按活动配置。拒绝必须发生在取号这一步,而不是等用户排到了才告诉他排不上。
-
同时在入口限流,让到达量本来就低于放行能力。排队是最后一道防线,第 5.1 节的令牌桶和第 5.2 节的答题都在前面挡着。排队系统自己不应该承担全部的流量控制职责。
-
提前告知排队人数:活动页显示”预计 50 万人参与”,让用户在点之前就知道自己大概率抢不到,从而选择不参与。这是成本最低的削峰——用户自己就不来了。
-
分批排队:如果确实需要让更多人参与,用分批放量——每批放 N 个名额,上一批没抢到且队列空了就开下一批。规则要简单明确:“每 5 分钟一批,每批 100 个名额”。
-
等待时间超长时怎么办:这比队列满了更需要处理,因为它伤害的是已经排上队的用户。三个手段——
- 提高放行速率(前提是下游扛得住)
- 引导用户离开(“预计等待超过 10 分钟,您可以选择稍后再来”)
- 引入预约(让用户在开抢前就分到时段,把 50 万人拆成 10 个 5 分钟的时段)
-
监控排队时长的 P99。队列长度只能反映容量压力,等待时长才是用户真正的感受。两个指标要一起看。
-
容量估算:队列人数 × 每条约 100 字节,10 万人约 10 MB,内存不是问题;取号和查进度的 QPS 才是压力所在,这两个接口要单独压测。
最终答案
容量靠三层控制:入口限流(令牌桶、答题)把到达量降下来,队列本身设上限并快速拒绝,活动页提前公示参与人数让用户自行分流。等待时间过长时靠提高放行速率、引导用户离开或引入预约来消化。容量上队列内存不是瓶颈,取号与查进度的 QPS 才是。
问题 3:如何防止用户作弊刷新排队号?
提示:
- 排队号和用户绑定
- 排队号一次性使用
- 设备指纹限制
解题思路
先问一句”作弊刷新排队号”到底想得到什么”。答案是插队——在队列里排到更靠前的位置。那么防御的目标就很明确:让”多刷一次”不能带来任何位置优势。
详细步骤
- 取号幂等:同一个用户永远只有一个号。取号脚本里先查
ZSCORE queue:waiting:{activityId} userId,存在就直接返回原号码,不重新分配。
用户连续点击 20 次抢购按钮:
→ 第一次:分配 12847 号
→ 后 19 次:检测到已在队列,返回 12847
→ 队列里只占 1 个位置-
不要按”点击次数”限流,要按”请求次数”限流并分级。合法用户偶尔会多点一次,脚本会成百上千次。合理的策略是:同一用户短时间内超过 N 次请求就触发二次验证(答题或验证码),而不是直接封禁——直接封杀会误伤网络不稳的真实用户。
-
排队号与用户身份绑定,一次性使用。放行后发放的一次性令牌只能用一次,用完即焚(
GETDEL);同一个排队号不能被用来下多单。这和 4.3 节的订单幂等键是同一个思路——服务端生成的唯一标识 + 唯一索引兜底。 -
限制”号”的收益。即使一个用户能拿到多个号,他也只有一个抢购资格——因为资格最终绑定的是用户和活动,而不是号本身。这是最根本的防御:让作弊拿到的号没有额外收益。
-
设备与账号维度限流:同一设备指纹、同一 IP、同一支付账号、同一收货信息关联的多个账号,都要计入同一个”人”的配额。第 7 章的身份核验、行为分析和黑名单机制,提供的正是这些信号。
-
刷新页面要能恢复,而不是重新排队。用户刷新后重新调取号接口拿回原号,这样正常的刷新行为不会受到惩罚,脚本也无法通过刷新获得新号。
-
识别异常模式:短时间内大量取号但从不查进度、取了号就消失、同一批号高度聚集在某个区间——这些都可以作为风控信号,交给行为分析处理。
最终答案
核心是幂等:取号接口对同一用户只返回原排队号,排队号与用户、活动绑定且一次性使用,作弊多拿到的号没有额外收益。配合按用户/设备/IP 维度的请求频次控制(超阈值转二次验证而非直接封禁)和第 7 章的行为分析信号,才能既挡住脚本又不误伤真实用户。
发现内容有问题?
告诉我们哪里需要改进。
