技术挑战:秒杀系统面临的技术难题

问题:系统为什么会崩溃?

上一节我们了解了秒杀业务的独特特点。现在让我们深入分析这些特点带来的技术挑战。

一个真实的崩溃场景:

输出:

💥 系统崩溃分析:

1️⃣ 数据库连接耗尽:
   正常 QPS: 1000
   秒杀 QPS: 500,000
   数据库连接池: 100
   每个连接处理的请求: 5000 个/秒
   平均等待时间: 50.0 秒
   结果: ❌ 大量请求超时,用户看到错误页面

2️⃣ 库存锁竞争:
   库存: 100 件
   并发请求: 5000 个
   锁等待: 每个请求都要排队等待
   总耗时: 50.0 秒
   结果: ❌ 数据库响应超时,连接池耗尽

3️⃣ 超卖问题:
   场景: 两个用户同时看到库存=1
   用户A: 读取库存=1,准备购买
   用户B: 读取库存=1,准备购买
   用户A: 扣减库存,库存=0
   用户B: 扣减库存,库存=-1
   结果: ❌ 超卖!库存变成负数,无法发货

挑战一:瞬时高并发 ⚡

这是所有秒杀系统最直观的挑战,也是最难的一个。它的难不在于”机器不够快”,而在于流量和供给之间的比例极端失衡——50 万个人抢 100 件东西,99.98% 的请求注定失败。

问题分析

秒杀最核心的挑战是瞬时高并发。但”高并发”这个词本身会误导人——真正难的并不是并发数高,而是并发是在一个极短的时间窗口内突然出现、然后又突然消失。日常电商面对的是持续压力(流量全天在 1000 QPS 上下波动,按峰值配机器就行);秒杀却是平时 1000 QPS、整点前后三秒冲到 50 万 QPS、三秒后回落。流量曲线不是”更高”,而是”更尖”——三角形而不是梯形。

这个差别带来三个直接后果:

  1. 不能按峰值长期配置资源。 为三秒的洪峰常备 500 倍的机器,成本上不可行;而等到洪峰来了再扩容,扩容的耗时(分钟级)远长于洪峰(秒级),根本来不及。
  2. 不能靠”平均”思考问题。 连接池、线程池、Redis 连接、数据库行锁都是按”一段时间内的平均并发”设计的,秒杀里它们会在同一瞬间被打满,等待队列把请求串成一条长龙。
  3. 失败是常态,而不是异常。 50 万人抢 100 件,99.98% 的请求注定失败。如果架构假设”每个请求都有机会成功”,那 99.98% 的算力就都浪费在了必然失败的请求上。

所以秒杀的架构问题本质上不是”怎么把系统做得更快”,而是”怎么让注定失败的请求尽可能便宜地失败”。这个判断会贯穿后面所有章节。

具体技术难点

把”瞬时高并发”拆开看,有五个互不相同的难点:

难点具体表现应对方向
到达时间不可预测不知道峰值是 5 万还是 50 万 QPS限流 + 弹性扩容预案
流量极度集中所有请求打在同一个商品、同一条库存记录缓存 + 原子操作,把热点从数据库挪走
供需严重失衡50 万人抢 100 件,99.98% 的请求必然失败让失败”快速且便宜”,不要让每个失败请求都打到后端
成本不能按峰值配置为 3 秒的峰值常备 500 倍的机器不可行削峰填谷,用队列把瞬时洪峰摊平
失败是常态绝大多数用户会收到”已售罄”失败路径要和成功路径一样被认真设计

最容易被低估的是第三条和第五条。

很多团队的秒杀系统是在”如何让抢到的人更快地完成下单”上花大力气,却忽略了另一半用户——那 49.99 万个注定抢不到的人。他们同样发起了完整的请求,如果每个请求都要打到数据库,系统的 99.98% 的算力都花在了必然失败的请求上。

这直接决定了秒杀架构的核心取舍:

❌ 朴素做法:所有请求 → 数据库 → 查库存 → 判断 → 扣减
   50 万次数据库往返,其中 49.99 万次注定白跑

✅ 秒杀做法:所有请求 → 内存 → 原子扣减 → 抢到的那 100 个才继续往下走
   数据库只处理 100 个请求

“快速失败”本身就是一种性能优化。把注定失败的请求在第一道门就挡掉,比让它们一路跑到数据库再失败,要便宜几个数量级。

挑战二:库存一致性 🔒

库存是一份全局共享的状态,而所有请求都想修改它。并发写的经典难题,在秒杀里被放到了最大倍率。

超卖问题演示

超卖的本质是读-改-写这三步不是原子的。

用户A: SELECT stock FROM product WHERE id = 1;  →  读到 stock = 1
用户B: SELECT stock FROM product WHERE id = 1;  →  读到 stock = 1
用户A: if (stock > 0) { ... }
用户B: if (stock > 0) { ... }                    ← 两人都认为还有货
用户A: UPDATE product SET stock = stock - 1;    →  stock = 0
用户B: UPDATE product SET stock = stock - 1;    →  stock = -1  ← 超卖

超卖比少卖严重得多:

超卖少卖
库存变成负数凭空消失
订单发不出去货用户没抢到
钱收了退不掉没收
处理赔钱 + 客诉 + 舆情补偿或下次活动
严重程度🔥 不可接受⚠️ 可以接受

少卖在秒杀里其实是常态:50 万人抢 100 件,99.98% 的人没抢到,这不是”少卖”,这是设计。真正的少卖故障是”库存明明有货却卖不出去”——比如库存被一个失败的超时订单长期占住,或者补偿逻辑重复执行把可售量算错了。

所以秒杀的一致性目标不是”不多卖也不少卖”,而是:

① 绝对不能超卖(卖出去的一定有货)
② 少卖可以接受,但必须是"可解释的少卖"(能被对账发现并修复)

这个目标定义,直接决定了后面几章的方案取向:宁可少卖,不能超卖。

数据库锁的问题

最直觉的修法是加锁。锁能保证正确,但它的代价在秒杀场景下是不可接受的。

悲观锁怎么把并发变串行

BEGIN;
SELECT stock FROM product WHERE id = 1 FOR UPDATE;   -- 拿不到行锁就一直等
-- 判断并扣减
UPDATE product SET stock = stock - 1 WHERE id = 1;
COMMIT;
50 万个请求 → 同一行 → 排成一条长长的队:
  请求1  ████
  请求2      ████
  请求3          ████
  ...
  请求500000                                      ████
  总耗时 = 50 万 × 单次事务耗时

锁在数据库里要付出四笔成本:

成本说明秒杀场景下的放大
等待时间排在别人后面,纯粹的时间损失与并发数成正比,50 万次排队
锁持有时间从加锁到提交事务的全过程包含网络往返和日志落盘,不只是业务逻辑
连接占用等待中的事务占着连接不放连接池被等待请求占满,正常业务也开始排队
吞吐上限同一行上并发度 = 1QPS = 1 / 单次事务耗时 ≈ 1,000-5,000

第三行是压死骆驼的最后一根稻草:一个 100 连接的池,被 50 万个等待锁的请求填满后,商品查询、用户信息这些完全不需要锁的正常业务,也一样拿不到连接。锁的等待会从秒杀链路蔓延到整站。

换个锁策略也不救场:

锁策略问题
表锁整张表串行,比行锁更糟
共享锁(读锁)读放大,写请求全部排队
缩小锁粒度库存就在一行上,没法再小了
读写分离写走主库,瓶颈还在主库

根本问题不是”锁写得不好”,而是”锁的位置选错了”。 50 万 QPS 这个量级,本来就不该让数据库来承担”判断还有没有货”这个工作。

判断”有没有货”是一个只读的、轻量的、绝大部分结果是”没有”的操作。它应该在更便宜的地方做——这就是第 4 章把库存搬到 Redis 的动机。

挑战三:恶意刷单 🤖

前三个挑战是”系统扛不扛得住”的问题,这一个不同:它考验的是系统在被人恶意利用时的表现。

黄牛和脚本问题

脚本是什么样的

下面是一个再普通不过的秒杀脚本:

import requests

while True:
    resp = requests.post(
        'https://example.com/seckill/buy',
        headers={'Cookie': 'session=xxx'},
        data={'sku_id': 1},
        timeout=1,
    )
    if resp.status_code == 200 and resp.json().get('success'):
        print('抢到了!')
        break

它比人快多少?

维度真人脚本
点击间隔0.3-1 秒10-50 毫秒
单账号 QPS1-320-100
工作时间3 秒7×24 小时
账号数量1成百上千

一个脚本账号的抢单速度是人的 30-100 倍。1000 个脚本账号,等价于 3 万到 10 万个真人。

更麻烦的是它会挤压正常用户:

100 件库存:
  脚本 拿走 60 件
  3 万个真人抢剩下的 40 件
  → 绝大多数正常用户连"提交"都没轮到

危害清单:

危害说明
公平性被破坏活动变成”脚本竞赛”,普通用户完全没机会
库存被占死脚本下单但不付款,库存被长时间占用
成本被浪费大量请求消耗服务器、带宽、Redis 连接
活动价值归零用户不再相信秒杀活动的公平性,下次不来了
商家损失真正的目标用户买不到,转化率下降

最后一条最难修复。技术问题可以靠更强的风控解决,但”用户觉得这个平台不公平”的信任问题,只能靠长期的公平体验慢慢挣回来。

防刷技术难点

防刷的难点可以概括成一句话:要识别”这是人还是机器”,但人和机器的边界本来就是模糊的。

具体的难点:

难点表现后果
判定标准模糊行为可以模仿,IP 可以代理,设备可以伪造规则越严,误伤真人越多
代理 IP 池一个用户换几十个出口 IP基于 IP 的限流全部失效
设备指纹可伪造改 UA、改分辨率、重置设备 ID基于设备的识别被绕过
行为可模仿脚本可以加入随机延时、模拟鼠标轨迹基于行为特征的识别被绕过
误伤成本高把真人当黄牛 = 客诉 + 投诉 + 舆情宁漏放一个黄牛,不可错伤一个用户
攻防是持续的今天有效的规则,明天可能被绕过上线不是终点,是起点

“误伤成本”这一条决定了防刷的设计原则:

误伤一个真人    →  1 个客诉 + 1 张截图 + 可能的舆情
漏放一个黄牛    →  多抢走几件库存,事后可以退款/限购回收

两者的代价完全不对等 → 策略必须偏保守 → 靠"多信号交叉"而不是"单信号判定"

所以成熟的做法是分层拦截,而不是靠某一个”强力检测”:

第 1 层:限流(按 IP / 设备 / 账号 / 全局)    ← 挡住 99% 的量,代价最小
第 2 层:验证码 / 答题(只对可疑流量)        ← 把脚本成本抬高到不划算
第 3 层:行为分析(操作间隔、轨迹、路径)      ← 识别高级脚本
第 4 层:风控评分 + 黑名单                    ← 处置累积确认的恶意账号

关键设计原则:越靠前的层越便宜、越无感;越靠后的层越准确、越有代价。 让 99.9% 的请求在最便宜的那层就被处理掉,剩下的才值得动用重手段。

还有两条容易被忽略的原则:

  1. 不要用”是否通过验证”泄露信息。 失败要返回统一提示,不要告诉脚本”你的设备已被识别”——那等于给攻击者一个反馈信号,让它能迭代优化。
  2. 规则要能被观测。 每条规则拦截了多少量、误伤了多少人,都要能看到。否则你既不知道规则是否有效,也不敢调整阈值。

具体的风控实现见第 7 章。

挑战四:公平性保证 ⚖️

前面三个挑战都是”系统层面”的。第四个是”用户层面”的:在同样的规则下,让每个参与者都有公平的机会。

时间同步问题

问题出在”几点开始”这件事上——而”几点开始”决定着谁先抢到。

用户A: 本地时钟慢 3 秒  →  他以为倒计时归零的那一刻,按钮才刚亮
用户B: 本地时钟快 5 秒  →  他的倒计时早就归零了,请求早就发出去了
服务端: 以自己的时钟为准

三个层面的时钟问题:

层面问题例子
客户端时钟用户可以随便改系统时间快 5 秒的设备提前 5 秒发请求
服务端时钟漂移多台机器之间有毫秒到秒级偏差A 机器已经放货,B 机器还在等
网络延迟请求到达服务端的时刻不确定用户看到倒计时 0,到达时可能已经过了 100ms

客户端时钟是最容易被攻击的一环:改一下系统时间,就能把自己的请求”提前”发出去。这在秒杀里是实打实的不公平,也是脚本农场的基本功。

应对方式:

1. 绝不信任客户端时间
   - 服务端在页面加载时下发一个绝对时间戳,客户端倒计时用「服务端时间 + 估算 RTT」校准
   - 判断"是否开始"永远由服务端做

2. 服务端之间保持时钟同步
   - NTP / Chrony 同步 + 监控 offset
   - offset 超过阈值告警

3. 关键节点由服务端统一裁决
   - 活动时间由服务端配置,不接受客户端参数
   - 真正的"开始"不是某一刻,而是令牌桶逐步放令牌的过程

4. 接受"绝对同时开始"不可得
   - 50 万人各自点下的时刻本来就不可能一致
   - 追求的不是"同时",而是"机会均等 + 顺序可解释"

第 3 点是理解秒杀公平性的关键。业界主流做法不是在某一刻同时开闸,而是在活动开始前的一段时间里,按预算逐步发放令牌(比如每 100ms 放一批)。这样做有三个好处:

  • 前 10 秒的流量是平稳的,不会瞬间打垮后端
  • 令牌分批释放,每个批次都是相对公平的竞争
  • 遇到突发流量有天然的缓冲空间

令牌桶的具体实现在第 5 章。

技术挑战总结

让我们总结一下秒杀系统的技术挑战:

挑战本质主要手段对应章节
瞬时高并发流量远大于资源,99.98% 的请求注定失败限流、削峰、缓存、原子操作第 4、5 章
库存一致性并发修改同一份共享状态原子扣减、条件更新、消息队列、对账第 2、3、4、6 章
恶意刷单自动化流量放大正常流量的危害限流、验证码、行为分析、黑名单第 5、7 章
公平性保证时钟不可信、到达顺序不可控服务端时间、令牌桶、排队第 5 章

这四个挑战不是并列的,它们有明确的层次:

入口层(公平性 + 防刷) → 决定"谁能进来"
   ↓
中间层(高并发)      → 决定"进来的怎么处理"
   ↓
末端层(一致性)      → 决定"处理的结果对不对"

从外到内,问题依次变窄、代价依次变高:

  • 入口层挡掉的是”根本不该来的请求”——不花钱,只是拒绝了
  • 中间层挡掉的是”来了但注定失败的请求”——花钱,但省掉了后续的开销
  • 末端层处理的是”真正要成交的那 100 单”——最贵,所以数量最少

这个层次关系决定了整个架构的形态:第 5 章的限流和防刷在最外层,第 4 章的 Redis 预扣和消息队列在中间层,第 3 章的数据库锁和第 6 章的一致性保证在最内层。越靠外的手段越便宜,所以要尽可能往外放。

想一想

在继续学习之前,请思考以下问题:

问题 1:为什么要用Redis?

为什么要把库存放在Redis而不是数据库?

提示:

  • Redis单线程,无锁竞争问题
  • Redis内存操作,速度快
  • Redis支持原子操作
Redis选型秒杀架构

解题思路

三条提示对应三个理由。但要回答好这个问题,还需要补上两条提示里没提的:为什么不是加机器,以及Redis 承担的是哪一部分职责。最后一点最关键——Redis 不是 MySQL 的替代品。

详细步骤

  1. 内存操作:Redis 的数据读写全在内存里,一次 GET/DECR 是亚微秒级;MySQL 的一次更新要走 Buffer Pool、索引维护、redo log、binlog、fsync 落盘,是毫秒到十毫秒级。延迟差三个数量级,而库存判断恰恰是个高频轻量操作。

  2. 单线程执行命令,没有锁竞争:Redis 用一个线程执行所有命令,执行时根本不存在线程竞争。数据库的锁则要真真切切地排队等待,还要占用连接。这直接对应第 3 章讲的”锁的等待会蔓延到整站”的问题。

  3. 原子操作:DECR 本身原子,Lua 脚本能把”判断 + 扣减”合成一个不可分割的动作。这让”判断还有没有货”这个操作不需要任何锁,也就没有死锁、没有重试、没有锁等待。

  4. 为什么不是加机器? 两个原因:

    • 成本:50 万 QPS 的峰值只持续几秒,按峰值常备机器在经济上不可行。
    • 更关键:横向扩容解决不了热点行的问题。库存只有一行,加再多台应用服务器,最终还是要抢那一行。除非做分库分表把库存拆开,但”全局库存只有 100 件”这个判断又需要跨分片汇总,反而更复杂。
  5. Redis 承担的是哪一部分? 提示里隐含了一个误解——好像 Redis 要取代数据库。实际分工是:

    RedisMySQL
    角色预扣层、流量筛选器事实来源
    回答的问题“还有没有货”“谁买了什么”
    流量50 万 QPS几千 QPS
    能否丢数据能(用对账修复)不能
  6. Redis 也有代价:主从复制是异步的,故障切换可能丢最后一批写;RDB 快照可能丢一个周期的数据。所以 Redis 只能是可重建的加速副本,不能当事实来源。

最终答案

用 Redis 是为了用”内存 + 单线程无锁 + 原子操作”这三件事,把”判断还有没有货”这个高频、轻量、绝大部分结果是”没有”的操作挪出数据库。不是加机器(成本扛不住,热点行也加不出来),也不是取代数据库——Redis 负责预扣和筛选,MySQL 仍然是订单与成交的最终事实。

问题 2:如何削峰填谷?

流量洪峰来了,如何避免系统崩溃?

提示:

  • 消息队列
  • 限流
  • 答题分散请求
削峰填谷消息队列限流秒杀架构

解题思路

削峰填谷的本质是”把瞬时的洪峰摊到一段时间里处理”。提示给了三条路,要说清每条作用在哪个维度——它们不是重复的三种做法,而是三个不同的阀门。

详细步骤

  1. 限流:控制”进系统的速率”。令牌桶按固定速率放行,超出的请求快速失败。它保护的是后端资源,代价是部分用户直接被拒。→ 第 5 章

  2. 消息队列:控制”处理的速率”。请求先进队列排队,后端按自己能承受的速度消费。它不丢请求,代价是用户要多等。→ 第 4.2、4.3 节

  3. 答题 / 验证码:控制”请求的到达分布”。把 50 万人的点击摊到 10 秒内,流量变成平滑的 5 万 QPS 而不是 50 万的尖峰。它同时提升公平性,因为所有人都在答题而不是拼手速。→ 第 5 章

  4. 三者的作用维度不同,所以要组合:

    手段作用维度解决的具体问题
    限流入口速率瞬时流量超过系统上限
    答题/验证码到达分布流量尖峰、脚本集中提交
    消息队列出口速率后端处理能力不足,削峰填谷
    业务性削峰总量库存只有 100 件,本就只需放行 100 个成功
  5. 业务性削峰是最省的一种:库存是有限的,系统只需要放行与库存量匹配的请求数。多出来的请求在第一道门就该被拒——这是第 2 章”快速失败”思路的直接应用。

  6. 最后一道是熔断降级:前面所有手段都失效时(比如 Redis 抖动导致令牌桶失效),要有兜底——把放行量降到最低、返回友好的”系统繁忙”提示,而不是让请求堆在服务里直到雪崩。

  7. 削峰的代价要说清楚:所有这些手段都在用”延迟”和”拒绝”换”存活”。在秒杀场景里这是划算的,因为绝大多数请求本来就会失败;但在普通业务里同样套用就会伤害体验。秒杀是特例,不要生搬硬套。

最终答案

限流控制入口速率、答题/验证码打散到达分布、消息队列控制出口速率,再叠加”按库存量决定放行量”的业务性削峰,最后用熔断降级兜底。核心思路是让注定失败的请求在尽可能便宜的地方被拒绝。

问题 3:如何保证公平?

如何确保所有用户公平抢购?

提示:

  • 时间同步
  • 隐藏秒杀URL
  • 答题验证
公平性时间同步令牌桶防作弊

解题思路

“公平”在秒杀里需要先定义清楚,否则无从谈起。它不等于”绝对同时开始”——50 万次点击物理上不可能同时发生。公平的含义是:机会均等 + 顺序可解释 + 不可作弊。三个提示分别对应这三层。

详细步骤

  1. 时间同步(防作弊的第一层):

    • 服务端下发权威时间戳,客户端倒计时用它校准,不用本地时钟
    • 服务端之间用 NTP / Chrony 同步,并把 offset 纳入监控
    • 判断”活动是否开始”永远由服务端裁决,不接受客户端传入的时间参数
  2. 隐藏秒杀URL(提高作恶门槛):活动地址在开始前不公开,配合预约资格,让攻击者无法提前准备账号和脚本。注意这只是提高门槛,不是万无一失——地址一旦泄露就失效,所以必须叠加后面几层。

  3. 答题验证(打散流量 + 公平竞争):所有人(人和脚本 alike)都要答题,把点击从”零点那一瞬”摊到接下来的一段时间里。这一招同时解决两件事:流量尖峰被拉平,机会从”手速”转向”参与资格”。

  4. 令牌桶分批发放(机会均等的核心机制):活动开始前的一段时间内按预算逐步放令牌,而不是某一刻同时开闸。这样流量是平稳的,每个批次都是相对公平的竞争。

  5. 队列化定序(顺序可解释):让用户拿到一个”请求已被受理”的凭证(排队号),并能查询自己的位置。这解决了”我明明点了却不知道算不算”的问题,也减少了用户因为不确定而反复重试的行为——而反复重试本身就是不公平的放大器。

  6. 多维限流(不可作弊的兜底):按 IP、设备指纹、账号三个维度分别限流。代理 IP 能绕过 IP 限流,但绕不过设备指纹和账号维度的约束。

  7. 要有可观测的公平性指标,否则”公平”只是口号:

    指标看什么
    各渠道成功率移动端和 PC 端是否差异明显
    各设备类型成功率是否某一类设备被系统性排斥
    响应时间分布是否只有少数用户秒回,多数人秒超时
    重试次数是否存在脚本特征的重试模式

最终答案

服务端权威时间 + 隐藏活动地址 + 答题分散 + 令牌桶分批放行 + 队列定序 + 多维限流防作弊,并用可观测的公平性指标持续验证。核心是让”抢”变成”排”,让优势来自参与资格而不是手速和脚本。

发现内容有问题?

告诉我们哪里需要改进。