关键决策:设计过程中的关键决策点
在设计秒杀系统的过程中,我们遇到了无数个选择题。有些选择看似微小,却可能影响整个系统的命运。
今天,让我们一起回顾那些关键决策点,看看我们为什么这样选,以及有没有更好的选择。
问题
回到 1.1 节的场景:库存 100 台 iPhone,50 万人参与,入口瞬时 50 万 QPS。
库存只有一份,却被 50 万个请求同时读取、判断、扣减。库存只有一个正确答案(100),但它要被访问 50 万次;剩下 49.99 万次访问,无论结果如何都只能得到”已售罄”。
问题在于:把这次判断放在哪里做。
❌ 放在 MySQL:
SELECT stock FROM product WHERE id = 1; -- 读
UPDATE product SET stock = stock - 1 ...; -- 写 + 行锁 + 刷盘
→ 单机峰值 1000-5000 QPS(第 3 章实测)
→ 与 50 万 QPS 差 100~500 倍,这不是调参能补的差距
✅ 放在 Redis:
GET stock:100 -- 内存读,微秒级
→ 单实例 100,000 QPS,读写都在内存
→ 但 Redis 是内存介质,宕机会丢数据
还有一个容易被忽略的算术:库存 100 件意味着有效请求最多 100 个。剩下 99.98% 的请求连”是不是卖完了”都不需要知道,它们只需要被便宜地、尽快地挡掉。让它们去惊动数据库、占用行锁、走完整条业务链路,是纯粹的浪费。
于是库存放在哪里就成了第一个必须回答的问题:放在 MySQL,性能不够;放在 Redis,可靠性不够。
决策分析
| 维度 | MySQL | Redis | MySQL+Redis |
|---|---|---|---|
| 读取性能 | 1000 QPS | 100,000 QPS | 100,000 QPS |
| 写入性能 | 500 QPS | 50,000 QPS | 50,000 QPS |
| 数据可靠性 | ★★★★★ | ★★★☆☆ | ★★★★☆ |
| 实现复杂度 | ★☆☆☆☆ | ★★☆☆☆ | ★★★★☆ |
| 一致性保证 | 强一致 | 最终一致 | 最终一致 |
我们的选择:Redis 为主,MySQL 为辅 ✅
结论:库存的主副本放在 Redis,MySQL 只负责保存”成交事实”。
具体做法是三件事:
- 判定与扣减都在 Redis 完成——用 Lua 脚本把”判断库存 + 扣减 + 写扣减流水”合并成一次原子操作(见 4.1 节),入口只要一次
EVALSHA就能拿到确定答案。 - MySQL 不参与实时链路——Redis 扣减成功后,通过消息队列异步把这次成交同步到 MySQL,由消费端落订单表、扣库存(见 6.1 节)。
- Redis 的不可靠用”可重建”来补偿——库存是从 MySQL 成交记录派生出来的数据:Redis 宕机后可以按成交记录重新预热(见 6.2 节对账机制)。
对照上面表格里的五个维度:
- 读取性能 100,000 QPS vs 1,000 QPS:这是选 Redis 的首要原因。99.98% 的无效请求在 Redis 这一层就能拿到”售罄”的答案,不再进入后续链路。
- 写入性能 50,000 QPS vs 500 QPS:扣减发生在内存,数据库写退化成异步的批量写入。
- 数据可靠性 ★★★☆☆ vs ★★★★★:Redis 的短板是”内存易失”。但这里有个关键差别——Redis 里存的是派生数据,不是唯一副本。MySQL 的成交记录是持久化的,Redis 随时可以从它重建。所以真正的风险不是”数据没了”,而是”重建期间开不了卖”,这个风险由预热和降级方案处理。
- 一致性保证:从强一致降级为最终一致,代价是引入一个不一致窗口(Redis 扣了、MySQL 还没扣)。这个代价必须配对账来收敛,否则少卖/超卖会一直存在(见 6.2、6.3 节)。
- 实现复杂度 ★★★★☆ 是最高的:预热、消息同步、对账补偿三套机制都要自己写、自己运维。这不是免费的午餐,是用工程复杂度换吞吐。
一句话总结:MySQL 负责”证明卖过”,Redis 负责”决定能不能卖”。
如果重来,会改变吗?
不会改变。这个方案在性能和可靠性之间取得了最佳平衡。对于秒杀场景,性能是第一位的,而通过异步对账可以弥补 Redis 的可靠性问题。
问题
把库存搬到 Redis 之后,超卖并没有消失,只是换了地方发生。
第 6.3 节把超卖的来源拆成三个源头,其中第一个是”并发扣减本身不原子”:100 个请求同时读到库存 = 100,都判断”够”,都扣减,于是卖出 101 台。
那用什么手段保证”判断”和”扣减”是一体的?摆在面前的有三条路:
❌ 悲观锁(MySQL 行锁)
SELECT ... FOR UPDATE → 持锁约 10ms → 释放
→ 100 并发排成一条队,每秒放行约 100 个
→ 50 万请求要排 83 分钟 ❌
❌ 乐观锁(版本号 / CAS)
UPDATE ... WHERE version = ? → 98% 的请求白做
→ 3.2 节实测:5000 并发时 QPS 只有 263,冲突率 98%
→ 冲突重试只是把排队从数据库挪到了应用层 ❌
✅ Redis 原子操作(Lua 脚本)
EVALSHA → Redis 单线程执行,判断与扣减之间不可能被插队
→ 4.1 节实测:10000 并发抢 100 件,原子性校验通过,QPS 6564
所以要决定的是:防超卖这道防线放在哪一层、由谁执行。放在数据库,防线最强但吞吐最低;放在应用层的 CAS,冲突会把服务打垮;放在 Redis 的单线程执行模型里,代价最小。
决策分析
| 方案 | 性能 | 一致性 | 实现复杂度 | 适用场景 |
|---|---|---|---|---|
| 悲观锁 | ★☆☆☆☆ | ★★★★★ | ★★☆☆☆ | 低并发 |
| 乐观锁 | ★★★☆☆ | ★★★★☆ | ★☆☆☆☆ | 中低并发 |
| Redis 原子 | ★★★★★ | ★★★☆☆ | ★★☆☆☆ | 高并发 |
| Lua 脚本 | ★★★★★ | ★★★★☆ | ★★★☆☆ | 超高并发 |
我们的选择:Redis Lua 脚本 ✅
结论:把”判断 + 扣减 + 流水”收敛成一次 Lua 脚本执行,由 Redis 的单线程模型保证原子性。
-- deduct.lua(要点)
local stock = redis.call('GET', KEYS[1])
if not stock then return -1 end -- key 不存在
if tonumber(stock) < tonumber(ARGV[1]) then return 0 end -- 已售罄
redis.call('DECRBY', KEYS[1], ARGV[1]) -- 扣减
redis.call('SET', KEYS[2], ARGV[2], 'EX', 3600) -- 扣减流水,供异步落库
return tonumber(stock) - tonumber(ARGV[1]) -- 返回剩余库存
对照表格里的四个维度:
- 性能 ★★★★★:脚本在内存中执行,单次 0.1-1ms,是四种方案里唯一扛得住 50 万 QPS 量级的。
- 一致性 ★★★★☆:比裸
DECR强得多——GET和DECR分两步写,中间存在间隙,100 个请求可以同时通过判断;合成脚本后间隙消失。扣掉一颗星是因为它仍然只是单实例内的原子性:Redis 集群跨节点、Redis 宕机丢数据、Redis 与 MySQL 不一致,这三件事 Lua 解决不了。 - 实现复杂度 ★★★☆☆:需要处理脚本缓存(
SCRIPT LOAD+EVALSHA,不要每次传全文)、集群下的 key 路由(同一商品的多把 key 必须落在同一 slot,用 hash tag{productId}保证)。比DECR复杂,但比引入分布式锁简单得多。 - 适用场景:超高并发——这正是秒杀的定义域。
关键提醒:Lua 挡住的是”源头 1”(并发竞态),不是全部。选它意味着必须同时保留另外两道防线——消费端在 MySQL 上再做一次条件更新 WHERE stock >= ?(挡住源头 2),以及定时对账与止损(挡住源头 3)。三道防线的分工见 6.3 节。
如果重来,会改变吗?
不会改变。Lua 脚本是防超卖的最佳实践,已经被业界广泛验证。
问题
拿到下单资格之后,用户立刻想知道的是”抢到了没有”。这一步有两种做法:
❌ 同步下单:
Redis 扣减成功 → 写订单表 → 扣库存表 → COMMIT → 返回
→ 第 3 章实测响应 500ms+,吞吐被数据库写盘钉死在几百 QPS
→ 50 万请求排队要十几分钟,用户全程盯着转圈 ❌
❌ 纯异步下单:
写队列 → 立刻返回"已受理"
→ 响应是快了,但用户不知道自己到底抢没抢到,只能反复刷新 ❌
还有一个容易被忽略的事实:秒杀订单的支付本来就是异步的。用户抢到资格之后的动作是”去付款”,付款可能发生在 30 秒后、5 分钟后。把订单创建也做成强同步,并没有换来等价的用户价值——用户要的是”名额保住了”,不是”订单行已经落库”。
所以真正的问题是:同步到哪一步为止。
决策分析
| 方案 | 响应时间 | 并发能力 | 用户体验 | 实现复杂度 |
|---|---|---|---|---|
| 同步下单 | 500ms+ | 1000 QPS | ★★★★★ | ★☆☆☆☆ |
| 异步下单 | 50ms | 50,000 QPS | ★★★☆☆ | ★★☆☆☆ |
| 混合模式 | 100ms | 30,000 QPS | ★★★★☆ | ★★★★☆ |
我们的选择:混合模式 ✅
结论:同步只做到”确认资格”,落库全部异步。
用户请求
↓
Redis Lua 扣减成功(资格到手)
↓
写入 Kafka 消息(下单请求)
↓
接口立即返回:"您已成功锁定名额,请在 5 分钟内完成支付"
↓
消费端异步:幂等校验 → 建订单 → 扣 MySQL 库存 → 推送通知
对照表格里的四个维度:
- 响应时间 50ms vs 500ms+:主链路上只剩一次 Redis 脚本 + 一次 Kafka 写入,两者都是内存操作和顺序写。
- 并发能力 50,000 QPS:写队列比写库便宜一个数量级,而且队列可以横向扩容;消费端再按 4.2 节的思路串行化,把并发写压力转成排队。
- 用户体验 ★★★★☆:比纯同步快 10 倍;比纯异步强在”确定性”——用户立刻拿到明确结果和订单号,不用刷新页面猜。扣一星是因为订单详情要等几十毫秒才能查到。
- 实现复杂度 ★★★★☆ 是三项里最高的:必须处理消息丢失、重复消费(幂等)、消费失败重试、死信队列、消费积压告警。这些在 6.1 节都展开过,也正是”混合模式”真正的成本所在。
什么时候选另外两种:如果业务允许”抢到后 10 分钟内付款、超时释放”(秒杀商品基本都是这个规则),异步就足够;如果库存极稀缺(比如全场只有 1 件)且必须当场出结果,或者涉及强合规场景(部分票务),可以退回复用”同步 + 限流”的组合,牺牲吞吐换确定性。
如果重来,会改变吗?
不会改变。混合模式是电商行业的标准做法,淘宝、京东都是这样做的。
问题
限流的位置决定了防护效果。前面算过一笔账:库存 100 件意味着 99.98% 的请求注定失败。如果这些请求都进了服务层,它们不会压垮数据库(库存只有 100 次写),但会压垮服务本身——网关连接数、应用线程池、Redis 连接、堆内存里堆积的请求对象。系统最终不是被库存压垮,而是被无效请求压垮,这是很多秒杀事故的真实死法。
那到底在哪一层限?各层能拦的东西完全不同:
只在 Nginx 限流:
→ 挡得住"网络层洪水",但挡不住换 IP / 换设备的攻击
→ 而且前端本地缓存、CDN 命中的请求根本到不了 Nginx
只在服务层限流:
→ 维度最细(用户、设备、商品),但请求已经穿过网关、鉴权、反欺诈
→ 每一次无效请求都消耗了完整链路的成本 ❌
分层限流:
→ 越靠前的层越便宜、拦下的请求越多
→ 越靠后的层越精确、维度越细
还要考虑维度:只按 IP 限流挡不住家庭/办公出口的共享 IP;只按用户限流挡不住”一个账号刷多台设备”;只按商品限流挡不住”黄牛专抢某几个 SKU”。限流维度必须和业务风险维度对齐。
决策分析
| 方案 | 性能影响 | 灵活性 | 配置复杂度 | 防护效果 |
|---|---|---|---|---|
| Nginx 限流 | ★☆☆☆☆ | ★★☆☆☆ | ★☆☆☆☆ | ★★★☆☆ |
| 网关限流 | ★★☆☆☆ | ★★★★☆ | ★★☆☆☆ | ★★★★☆ |
| 服务层限流 | ★★★☆☆ | ★★★★★ | ★★★☆☆ | ★★★★☆ |
| 多层限流 | ★★★★☆ | ★★★★★ | ★★★★★ | ★★★★★ |
我们的选择:多层限流 ✅
结论:四层叠加,每层各管一段。
| 层 | 限流对象 | 典型阈值 | 拦截的问题 |
|---|---|---|---|
| Nginx | 单 IP 请求速率 | 1000 次/秒 | 网络层洪水、无效扫描 |
| API Gateway | 全局 + 单商品(令牌桶,Redis 分布式计数) | 全局 10 万 QPS,商品 5000 QPS | 超出后端承载能力的流量 |
| 服务层 | 单用户 / 单设备 / 单账号 | 单用户 1 次/秒 | 同一账号多设备刷单 |
| 队列 | 消费速率 | 按后端实际处理能力 | 超过消费能力的堆积 |
对照表格里的四个维度:
- 防护效果 ★★★★★:纵深防御。四层各自拦下不同类型的问题,任何一层单独失效都不会让系统被打穿。
- 灵活性 ★★★★★:阈值、维度、封禁时长都能按活动配置下发,不需要发版。秒杀商品和普通商品的阈值本来就完全不同,这个能力是刚需。
- 性能影响 ★★★★☆:限流本身有成本(Redis 计数 + 申请令牌),但换来了”后端只处理该处理的量”。
- 配置复杂度 ★★★★★ 是唯一的负项:多层、多维、多种限流器叠在一起,配置错了会误杀真实用户。所以限流配置必须集中管理、支持灰度、支持一键回滚,并且配一块”限流看板”——限流指标要和 QPS 指标放在一起看,否则你分不清”限流生效了”和”流量本来就变少了”。
关键纪律:限流阈值要由业务量推导,不能拍脑袋。库存 100 件的商品,预热、校验类请求的放行量取库存数的 10~50 倍是常见起点——太小会误杀真实用户,太大则失去削峰意义。
如果重来,会改变吗?
不会改变。多层限流虽然配置复杂,但在高并发场景下是必不可少的。每一层都有不同的职责,形成纵深防御。
问题
缓存选得对不对,直接决定了主链路上还剩多少数据库压力。
回头看 1.2 节算过的账:一次 3 秒的秒杀里,商品详情、活动配置、商品图片这些数据是完全不变的——活动一开,价格、库存总量、规则就固定了。如果每个请求都去查 MySQL,等于用最贵的介质存最不变的数据:
一次 50 万请求的秒杀期间,典型的读放大:
商品详情查询 50 万次 ← 数据全程不变,查 1 次就够
库存查询 50 万次 ← 真正变化的只有 100 次
活动配置 5 万次 ← 活动开始前配置完就再也不用查
写侧的放大同样致命:扣库存只发生 100 次,但如果每次扣减都要同步更新”商品详情缓存”,就额外产生了 100 次写 + 失效广播 + 集群间同步。
所以要决定的是:哪些数据放哪一层缓存,写路径要不要跟着更新每一层。
决策分析
| 方案 | 读性能 | 写性能 | 一致性 | 成本 |
|---|---|---|---|---|
| 单层 Redis | 5ms | 5ms | ★★★★☆ | 中 |
| 多级缓存 | 1ms | 10ms | ★★★☆☆ | 低 |
| 只本地缓存 | 0.1ms | 0.1ms | ★☆☆☆☆ | 最低 |
我们的选择:多级缓存 ✅
结论:四级缓存,读路径由近到远,写路径只写 Redis。
读路径:本地缓存(Caffeine)→ Redis → MySQL
写路径:只更新 Redis,MySQL 异步落库,本地缓存靠 TTL 过期或广播失效
| 层级 | 缓存内容 | TTL | 一致性要求 |
|---|---|---|---|
| 浏览器 / CDN | 活动页 HTML/JS/CSS | 分钟级 | 静态 |
| 本地缓存 Caffeine | 活动配置、商品元数据 | 10-60s | 允许短时不一致 |
| Redis | 库存、限流计数、黑名单、扣减流水 | 分钟级 | 强相关 |
| MySQL | 订单、用户、成交记录 | — | 事实来源 |
对照表格里的五个维度:
- 读性能:本地命中 0.1ms、Redis 命中 5ms,对比直接查库的 10ms+——而且数据库是被全系统共享的资源,它的时间不只属于你。
- 写性能 10ms:写路径是”写 Redis + 异步落库”,比同步写 MySQL 便宜得多;而且写多级缓存的代价是 O(层数),只写一层就避开了本地缓存与集群之间的失效广播。
- 一致性 ★★★☆☆ 是这个方案的短板:本地缓存感知不到 Redis 的更新,只能靠 TTL 过期。所以必须定死一条纪律——本地缓存只放”活动开始后就不会变”的数据,而且必须有 TTL 和主动失效通道。库存、限流计数这类数据放本地,一定会出现超卖或限流失效。
- 成本 ★☆ 最低:本地缓存几乎不要钱,最贵的是 Redis 集群。
为什么不用单层 Redis:单层 Redis 一致性更好、实现更简单,但活动开始前那 50 万次商品详情查询都要打到 Redis 集群上,纯属浪费。多级缓存省下的不是几个毫秒,而是把”读放大”挡在后端之前。
如果重来,会改变吗?
基本不会改变。多级缓存是高性能系统的标配。但如果数据一致性要求极高,可能需要考虑使用 Redis 单层的方案。
问题
第 2.3 节讲了黄牛的三种手段,第 7 章给了身份验证、行为分析、黑名单三件武器。现在要决定的是做多少:
❌ 只做基础(限流 + 验证码):
→ 开发成本 1 周,但有 100 个账号的脚本团队 3 天就能绕过
→ 识别率 50%,等于给黄牛发了一张短期通行证
❌ 直接上深度(机器学习模型):
→ 需要标注数据、特征平台、模型迭代,3 个月起步
→ 还要有模型监控、漂移检测、回滚机制
→ 第一版模型在真实数据上的误杀率往往比预期高
✅ 进阶(设备指纹 + 行为分析 + 黑名单):
→ 1 个月,识别率 80%,误杀率 < 0.5%
更要命的是反欺诈是双刃剑。阈值太松拦不住黄牛,太紧会误杀真实用户——而被误杀的用户会去投诉、去社交媒体发帖,造成的 GMV 损失和口碑损失可能比黄牛抢走的还多。7.3 节的黑名单数据里,“申诉解封率 ~15%“这句话本身就说明误杀是真实存在的。
所以要决定的是:在”拦得住”和”不误杀”之间,用多少成本换哪一头。
决策分析
| 方案 | 开发成本 | 运维成本 | 识别率 | 误杀率 |
|---|---|---|---|---|
| 基础 | 1 周 | 低 | 50% | < 0.1% |
| 进阶 | 1 月 | 中 | 80% | < 0.5% |
| 深度 | 3 月+ | 高 | 95% | < 1% |
我们的选择:进阶反欺诈 ✅
结论:以”设备指纹 + 行为分析 + 黑名单”三件套为核心,验证码/答题作为兜底,不引入机器学习模型。
| 手段 | 拦什么 | 成本 | 信号强度 |
|---|---|---|---|
| 设备指纹(7.1 节) | 同一设备挂多个账号 | 低 | 强 |
| 行为分析(7.2 节) | 脚本的操作间隔、鼠标轨迹 | 低 | 强 |
| 黑名单(7.3 节) | 已确认的黄牛维度 | 低 | 强 |
| 验证码 / 答题(5.2 节) | 通用自动化脚本 | 中 | 中 |
对照表格里的五个维度:
- 开发成本 1 个月:三件套的共同点是”规则 + 存储 + 离线分析”,不需要标注数据,不需要训练场,团队可以边写边调。
- 识别率 80%:靠的是高信号规则而不是模型泛化。回顾第 2.3 节的数据——脚本从页面加载到点击购买只要 50ms,人类平均 2000ms,这种量级的差异用一条阈值就能抓住,不需要 AI。
- 误杀率 < 0.5%:规则是可解释的,可解释才能让运营看懂”为什么封了你”,才能支持人工复核和申诉。这一点是深度方案给不了的——模型只吐出一个 0.87 的分数,没人能据此做人工决策。
- 运维成本中等:调整阈值就是改配置,可以灰度,出问题能一键回滚,不需要重训模型。
明确的能力边界(这一条同样重要):这个方案挡不住”真人众包”和”刻意打散行为的高级脚本”——它们会模拟人类节奏、会用真实鼠标轨迹。识别它们需要更深的历史信号(账号关联图谱、收货地址聚类),属于”深度反欺诈”的范畴。等我们有了真实数据和明确的误杀投诉,再把这部分升级上去。
如果重来,会改变吗?
可能会调整。如果预算充足,可以直接上深度反欺诈。但如果资源有限,进阶方案是最佳起点。
| # | 决策点 | 我们的选择 | 关键机制 | 主要代价 | 可回退性 |
|---|---|---|---|---|---|
| 1 | 库存放在哪里 | Redis 为主,MySQL 为辅 | Lua 预扣 + 异步同步 + 对账 | 一致性窗口 | 高(库存可重建) |
| 2 | 如何防止超卖 | Redis Lua 脚本 | 单线程原子执行 | 依赖 Redis 存活 | 中(MySQL 条件更新兜底) |
| 3 | 同步还是异步下单 | 混合模式 | 同步给资格,异步落库 | 消息可靠性、幂等 | 中(可退回同步) |
| 4 | 如何限流 | 多层限流 | Nginx + 网关 + 服务 + 队列 | 配置复杂度 | 高(阈值可调) |
| 5 | 缓存策略 | 多级缓存 | 本地 + Redis 分层 | 本地缓存一致性 | 高(可降为单层) |
| 6 | 反欺诈做到什么程度 | 进阶反欺诈 | 指纹 + 行为 + 黑名单 | 误杀与投诉 | 高(阈值可调) |
这张表的用法:最后两列是应急时最先看的。“可回退性”高,意味着出事当天就能降级回去;“主要代价”写得明确,意味着我们知道每个方案换掉了什么、以及它会在什么地方先出问题。
问题 1:如果预算只有现在的 1/10,哪些决策需要改变?
点击查看答案
精简方案:
- 库存存储:只用 Redis(去掉 MySQL 实时同步)
- 限流策略:只用 Nginx 限流
- 缓存策略:只用 Redis(去掉本地缓存)
- 反欺诈:只用基础方案(限流 + 验证码)
- 服务器:全部减半,用更低配置
核心原则:保证核心功能(库存扣减),砍掉辅助功能
问题 2:如果流量是现在的 10 倍,哪些决策需要改变?
点击查看答案
升级方案:
- 库存存储:Redis 集群扩容,增加分片
- 下单模式:更激进的异步,同步只返回令牌
- 限流策略:更严格,提前拦截
- 缓存策略:增加 L0 缓存(CPU 缓存级别)
- 反欺诈:上机器学习模型,提前识别
核心原则:用空间换时间,用预处理换实时性能
问题 3:这些决策中,哪个最可能后悔?
点击查看答案
可能后悔的:
- 多级缓存的一致性维护(容易出 bug)
- 混合下单模式的用户通知(容易遗漏)
- 反欺诈的误杀处理(用户投诉)
建议:
- 做好监控和告警
- 建立快速回滚机制
- 准备应急预案
发现内容有问题?
告诉我们哪里需要改进。
