排队系统:设计排队系统削峰

问题:50万人挤进来,谁能抢到?🤷

限流和答题之后,还有个关键问题:

50 万人参与,库存只有 100 件
  ↓
限流挡住 48 万(令牌桶)
  ↓
答题再挡住 1.5 万
  ↓
剩下 5,000 个请求,在同一秒内涌进秒杀接口
  ↓
秒杀接口 → Redis 扣库存 → 队列 → 消费者 → MySQL

这 5,000 个请求在 1 秒内到达,而第 4 章的队列按 2,000 QPS 的速度消化——它们会在队列里堆成一座小山,用户等好几秒才拿到结果。 更糟的情况是,如果限流阈值配得宽松一点,5 万个请求同时进来,队列会直接堆到上百万条。

所以限流之后还需要最后一道:排队。

先说清楚排队和限流的区别,这是很多人混淆的地方:

限流排队
对超出的请求直接拒绝让它等着
用户体验“请求过多,请稍后”“您前面还有 3,271 人,预计等待 2 分钟”
解决的问题保护后端不被压垮把瞬时洪峰摊平成稳定流量
公平性不保证(谁先到谁进)强(先到先得)
系统利用率低(拒绝的用户白白流失)高(每个请求都有明确的去处)

限流是门卫,排队是号贩。 门卫把人挡在门外,号贩给人发号——号还是排上了,只是要等。

排队系统要解决的是三个具体问题:

  1. 削峰:把 5 万个瞬时请求,转换成每分钟稳定放行 N 个的涓流,让下游永远只面对 N 的压力。
  2. 公平:先到先得,可预期、可解释。谁抢到谁没抢到,不能靠运气。
  3. 可解释:用户随时知道自己排在第几、还要等多久、会不会轮到自己。

第 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优先?
  • 随机排队号?
排队公平排队号设计反作弊

解题思路

先分清两种”公平”:机会公平(每个人都有平等的机会参与)和结果公平(先到的人优先)。秒杀业务真正要的是后者——先到先得,因为商品是限量的,先到先得是用户最能接受、也最容易解释的规则。

详细步骤

  1. 排队号必须由服务端生成,且严格递增。用 Redis 的 INCR 分配号,天然满足唯一性和顺序性。绝不能由客户端生成或随机分配——随机号会让”早到的人反而排在后面”,直接违背直觉。

  2. 先到先得是默认规则。用户点击”立即抢购”的那一刻分配号码,号码大小就是顺序。

  3. 把”点击时间”和”取号时间”区分开。用户 0 时刻点了按钮,但网络抖动导致 0.3 秒才到服务端,取到的是第 12847 号而不是第 1 号。这不是系统的问题,是网络延迟,但可以通过前端预取号来改善:在活动开始前 5 秒就允许用户”预排队”,页面加载时就拿到号,开抢瞬间直接用这个号下单。

  4. VIP 优先要谨慎。给会员更高优先级在商业上常见,但在秒杀上极其敏感——“花钱就能插队”很容易引发舆情。如果要做,规则必须公开、明确、可预期(页面上写清楚”会员优先 30 秒”),而不是偷偷给。

  5. 真正的公平来自”规则透明”而不是”算法精巧”。一个所有人都能理解的规则(先到先得),比一个没人说得清的”智能排队算法”更公平,也更抗投诉。

  6. 配套防作弊:排队号与用户 ID 绑定、一次性使用、同一设备/账号只能取一个号。这些在第 7 章的反作弊里有更完整的方案。

最终答案

用服务端 INCR 生成的严格递增排队号实现先到先得,规则对所有用户公开透明;配合前端预取号减少网络抖动带来的不公平;VIP 优先如果要做就必须明示,绝不暗箱操作。公平的本质是”可预期的规则”,不是”复杂的算法”。

问题 2:排队用户太多怎么办?

提示:

  • 队列长度限制?
  • 预先告知排队人数?
  • 分批排队?
排队容量限流配合降级

解题思路

“排队用户太多”要分两种情况:排队人数超过容量(队列装不下)和等待时间超过用户耐心(队列装得下但排太久)。两种问题的解法完全不同。

详细步骤

  1. 超过容量:设上限并快速拒绝。取号时检查当前人数,超过上限直接返回”队列已满”。上限要留出余量,并按活动配置。拒绝必须发生在取号这一步,而不是等用户排到了才告诉他排不上。

  2. 同时在入口限流,让到达量本来就低于放行能力。排队是最后一道防线,第 5.1 节的令牌桶和第 5.2 节的答题都在前面挡着。排队系统自己不应该承担全部的流量控制职责。

  3. 提前告知排队人数:活动页显示”预计 50 万人参与”,让用户在点之前就知道自己大概率抢不到,从而选择不参与。这是成本最低的削峰——用户自己就不来了。

  4. 分批排队:如果确实需要让更多人参与,用分批放量——每批放 N 个名额,上一批没抢到且队列空了就开下一批。规则要简单明确:“每 5 分钟一批,每批 100 个名额”。

  5. 等待时间超长时怎么办:这比队列满了更需要处理,因为它伤害的是已经排上队的用户。三个手段——

    • 提高放行速率(前提是下游扛得住)
    • 引导用户离开(“预计等待超过 10 分钟,您可以选择稍后再来”)
    • 引入预约(让用户在开抢前就分到时段,把 50 万人拆成 10 个 5 分钟的时段)
  6. 监控排队时长的 P99。队列长度只能反映容量压力,等待时长才是用户真正的感受。两个指标要一起看。

  7. 容量估算:队列人数 × 每条约 100 字节,10 万人约 10 MB,内存不是问题;取号和查进度的 QPS 才是压力所在,这两个接口要单独压测。

最终答案

容量靠三层控制:入口限流(令牌桶、答题)把到达量降下来,队列本身设上限并快速拒绝,活动页提前公示参与人数让用户自行分流。等待时间过长时靠提高放行速率、引导用户离开或引入预约来消化。容量上队列内存不是瓶颈,取号与查进度的 QPS 才是。

问题 3:如何防止用户作弊刷新排队号?

提示:

  • 排队号和用户绑定
  • 排队号一次性使用
  • 设备指纹限制
反作弊幂等设计设备指纹

解题思路

先问一句”作弊刷新排队号”到底想得到什么”。答案是插队——在队列里排到更靠前的位置。那么防御的目标就很明确:让”多刷一次”不能带来任何位置优势。

详细步骤

  1. 取号幂等:同一个用户永远只有一个号。取号脚本里先查 ZSCORE queue:waiting:{activityId} userId,存在就直接返回原号码,不重新分配。
用户连续点击 20 次抢购按钮:
  → 第一次:分配 12847 号
  → 后 19 次:检测到已在队列,返回 12847
  → 队列里只占 1 个位置
  1. 不要按”点击次数”限流,要按”请求次数”限流并分级。合法用户偶尔会多点一次,脚本会成百上千次。合理的策略是:同一用户短时间内超过 N 次请求就触发二次验证(答题或验证码),而不是直接封禁——直接封杀会误伤网络不稳的真实用户。

  2. 排队号与用户身份绑定,一次性使用。放行后发放的一次性令牌只能用一次,用完即焚(GETDEL);同一个排队号不能被用来下多单。这和 4.3 节的订单幂等键是同一个思路——服务端生成的唯一标识 + 唯一索引兜底。

  3. 限制”号”的收益。即使一个用户能拿到多个号,他也只有一个抢购资格——因为资格最终绑定的是用户和活动,而不是号本身。这是最根本的防御:让作弊拿到的号没有额外收益。

  4. 设备与账号维度限流:同一设备指纹、同一 IP、同一支付账号、同一收货信息关联的多个账号,都要计入同一个”人”的配额。第 7 章的身份核验、行为分析和黑名单机制,提供的正是这些信号。

  5. 刷新页面要能恢复,而不是重新排队。用户刷新后重新调取号接口拿回原号,这样正常的刷新行为不会受到惩罚,脚本也无法通过刷新获得新号。

  6. 识别异常模式:短时间内大量取号但从不查进度、取了号就消失、同一批号高度聚集在某个区间——这些都可以作为风控信号,交给行为分析处理。

最终答案

核心是幂等:取号接口对同一用户只返回原排队号,排队号与用户、活动绑定且一次性使用,作弊多拿到的号没有额外收益。配合按用户/设备/IP 维度的请求频次控制(超阈值转二次验证而非直接封禁)和第 7 章的行为分析信号,才能既挡住脚本又不误伤真实用户。

发现内容有问题?

告诉我们哪里需要改进。