技术挑战:秒杀系统面临的技术难题
上一节我们了解了秒杀业务的独特特点。现在让我们深入分析这些特点带来的技术挑战。
一个真实的崩溃场景:
输出:
💥 系统崩溃分析:
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、三秒后回落。流量曲线不是”更高”,而是”更尖”——三角形而不是梯形。
这个差别带来三个直接后果:
- 不能按峰值长期配置资源。 为三秒的洪峰常备 500 倍的机器,成本上不可行;而等到洪峰来了再扩容,扩容的耗时(分钟级)远长于洪峰(秒级),根本来不及。
- 不能靠”平均”思考问题。 连接池、线程池、Redis 连接、数据库行锁都是按”一段时间内的平均并发”设计的,秒杀里它们会在同一瞬间被打满,等待队列把请求串成一条长龙。
- 失败是常态,而不是异常。 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 万次排队 |
| 锁持有时间 | 从加锁到提交事务的全过程 | 包含网络往返和日志落盘,不只是业务逻辑 |
| 连接占用 | 等待中的事务占着连接不放 | 连接池被等待请求占满,正常业务也开始排队 |
| 吞吐上限 | 同一行上并发度 = 1 | QPS = 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 毫秒 |
| 单账号 QPS | 1-3 | 20-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% 的请求在最便宜的那层就被处理掉,剩下的才值得动用重手段。
还有两条容易被忽略的原则:
- 不要用”是否通过验证”泄露信息。 失败要返回统一提示,不要告诉脚本”你的设备已被识别”——那等于给攻击者一个反馈信号,让它能迭代优化。
- 规则要能被观测。 每条规则拦截了多少量、误伤了多少人,都要能看到。否则你既不知道规则是否有效,也不敢调整阈值。
具体的风控实现见第 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 不是 MySQL 的替代品。
详细步骤
-
内存操作:Redis 的数据读写全在内存里,一次 GET/DECR 是亚微秒级;MySQL 的一次更新要走 Buffer Pool、索引维护、redo log、binlog、fsync 落盘,是毫秒到十毫秒级。延迟差三个数量级,而库存判断恰恰是个高频轻量操作。
-
单线程执行命令,没有锁竞争:Redis 用一个线程执行所有命令,执行时根本不存在线程竞争。数据库的锁则要真真切切地排队等待,还要占用连接。这直接对应第 3 章讲的”锁的等待会蔓延到整站”的问题。
-
原子操作:
DECR本身原子,Lua 脚本能把”判断 + 扣减”合成一个不可分割的动作。这让”判断还有没有货”这个操作不需要任何锁,也就没有死锁、没有重试、没有锁等待。 -
为什么不是加机器? 两个原因:
- 成本:50 万 QPS 的峰值只持续几秒,按峰值常备机器在经济上不可行。
- 更关键:横向扩容解决不了热点行的问题。库存只有一行,加再多台应用服务器,最终还是要抢那一行。除非做分库分表把库存拆开,但”全局库存只有 100 件”这个判断又需要跨分片汇总,反而更复杂。
-
Redis 承担的是哪一部分? 提示里隐含了一个误解——好像 Redis 要取代数据库。实际分工是:
Redis MySQL 角色 预扣层、流量筛选器 事实来源 回答的问题 “还有没有货” “谁买了什么” 流量 50 万 QPS 几千 QPS 能否丢数据 能(用对账修复) 不能 -
Redis 也有代价:主从复制是异步的,故障切换可能丢最后一批写;RDB 快照可能丢一个周期的数据。所以 Redis 只能是可重建的加速副本,不能当事实来源。
最终答案
用 Redis 是为了用”内存 + 单线程无锁 + 原子操作”这三件事,把”判断还有没有货”这个高频、轻量、绝大部分结果是”没有”的操作挪出数据库。不是加机器(成本扛不住,热点行也加不出来),也不是取代数据库——Redis 负责预扣和筛选,MySQL 仍然是订单与成交的最终事实。
问题 2:如何削峰填谷?
流量洪峰来了,如何避免系统崩溃?
提示:
- 消息队列
- 限流
- 答题分散请求
解题思路
削峰填谷的本质是”把瞬时的洪峰摊到一段时间里处理”。提示给了三条路,要说清每条作用在哪个维度——它们不是重复的三种做法,而是三个不同的阀门。
详细步骤
-
限流:控制”进系统的速率”。令牌桶按固定速率放行,超出的请求快速失败。它保护的是后端资源,代价是部分用户直接被拒。→ 第 5 章
-
消息队列:控制”处理的速率”。请求先进队列排队,后端按自己能承受的速度消费。它不丢请求,代价是用户要多等。→ 第 4.2、4.3 节
-
答题 / 验证码:控制”请求的到达分布”。把 50 万人的点击摊到 10 秒内,流量变成平滑的 5 万 QPS 而不是 50 万的尖峰。它同时提升公平性,因为所有人都在答题而不是拼手速。→ 第 5 章
-
三者的作用维度不同,所以要组合:
手段 作用维度 解决的具体问题 限流 入口速率 瞬时流量超过系统上限 答题/验证码 到达分布 流量尖峰、脚本集中提交 消息队列 出口速率 后端处理能力不足,削峰填谷 业务性削峰 总量 库存只有 100 件,本就只需放行 100 个成功 -
业务性削峰是最省的一种:库存是有限的,系统只需要放行与库存量匹配的请求数。多出来的请求在第一道门就该被拒——这是第 2 章”快速失败”思路的直接应用。
-
最后一道是熔断降级:前面所有手段都失效时(比如 Redis 抖动导致令牌桶失效),要有兜底——把放行量降到最低、返回友好的”系统繁忙”提示,而不是让请求堆在服务里直到雪崩。
-
削峰的代价要说清楚:所有这些手段都在用”延迟”和”拒绝”换”存活”。在秒杀场景里这是划算的,因为绝大多数请求本来就会失败;但在普通业务里同样套用就会伤害体验。秒杀是特例,不要生搬硬套。
最终答案
限流控制入口速率、答题/验证码打散到达分布、消息队列控制出口速率,再叠加”按库存量决定放行量”的业务性削峰,最后用熔断降级兜底。核心思路是让注定失败的请求在尽可能便宜的地方被拒绝。
问题 3:如何保证公平?
如何确保所有用户公平抢购?
提示:
- 时间同步
- 隐藏秒杀URL
- 答题验证
解题思路
“公平”在秒杀里需要先定义清楚,否则无从谈起。它不等于”绝对同时开始”——50 万次点击物理上不可能同时发生。公平的含义是:机会均等 + 顺序可解释 + 不可作弊。三个提示分别对应这三层。
详细步骤
-
时间同步(防作弊的第一层):
- 服务端下发权威时间戳,客户端倒计时用它校准,不用本地时钟
- 服务端之间用 NTP / Chrony 同步,并把 offset 纳入监控
- 判断”活动是否开始”永远由服务端裁决,不接受客户端传入的时间参数
-
隐藏秒杀URL(提高作恶门槛):活动地址在开始前不公开,配合预约资格,让攻击者无法提前准备账号和脚本。注意这只是提高门槛,不是万无一失——地址一旦泄露就失效,所以必须叠加后面几层。
-
答题验证(打散流量 + 公平竞争):所有人(人和脚本 alike)都要答题,把点击从”零点那一瞬”摊到接下来的一段时间里。这一招同时解决两件事:流量尖峰被拉平,机会从”手速”转向”参与资格”。
-
令牌桶分批发放(机会均等的核心机制):活动开始前的一段时间内按预算逐步放令牌,而不是某一刻同时开闸。这样流量是平稳的,每个批次都是相对公平的竞争。
-
队列化定序(顺序可解释):让用户拿到一个”请求已被受理”的凭证(排队号),并能查询自己的位置。这解决了”我明明点了却不知道算不算”的问题,也减少了用户因为不确定而反复重试的行为——而反复重试本身就是不公平的放大器。
-
多维限流(不可作弊的兜底):按 IP、设备指纹、账号三个维度分别限流。代理 IP 能绕过 IP 限流,但绕不过设备指纹和账号维度的约束。
-
要有可观测的公平性指标,否则”公平”只是口号:
指标 看什么 各渠道成功率 移动端和 PC 端是否差异明显 各设备类型成功率 是否某一类设备被系统性排斥 响应时间分布 是否只有少数用户秒回,多数人秒超时 重试次数 是否存在脚本特征的重试模式
最终答案
服务端权威时间 + 隐藏活动地址 + 答题分散 + 令牌桶分批放行 + 队列定序 + 多维限流防作弊,并用可观测的公平性指标持续验证。核心是让”抢”变成”排”,让优势来自参与资格而不是手速和脚本。
发现内容有问题?
告诉我们哪里需要改进。
