关键决策:设计过程中的关键决策点

设计就是做选择 🎯

在设计秒杀系统的过程中,我们遇到了无数个选择题。有些选择看似微小,却可能影响整个系统的命运。

今天,让我们一起回顾那些关键决策点,看看我们为什么这样选,以及有没有更好的选择。


决策 1:库存放在哪里?📦

问题

回到 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,可靠性不够。

决策分析

维度MySQLRedisMySQL+Redis
读取性能1000 QPS100,000 QPS100,000 QPS
写入性能500 QPS50,000 QPS50,000 QPS
数据可靠性★★★★★★★★☆☆★★★★☆
实现复杂度★☆☆☆☆★★☆☆☆★★★★☆
一致性保证强一致最终一致最终一致

我们的选择:Redis 为主,MySQL 为辅 ✅

结论:库存的主副本放在 Redis,MySQL 只负责保存”成交事实”。

具体做法是三件事:

  1. 判定与扣减都在 Redis 完成——用 Lua 脚本把”判断库存 + 扣减 + 写扣减流水”合并成一次原子操作(见 4.1 节),入口只要一次 EVALSHA 就能拿到确定答案。
  2. MySQL 不参与实时链路——Redis 扣减成功后,通过消息队列异步把这次成交同步到 MySQL,由消费端落订单表、扣库存(见 6.1 节)。
  3. 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 的可靠性问题。


决策 2:如何防止超卖?🛡️

问题

把库存搬到 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 脚本是防超卖的最佳实践,已经被业界广泛验证。


决策 3:同步下单还是异步下单?🔄

问题

拿到下单资格之后,用户立刻想知道的是”抢到了没有”。这一步有两种做法:

❌ 同步下单:
   Redis 扣减成功 → 写订单表 → 扣库存表 → COMMIT → 返回
   → 第 3 章实测响应 500ms+,吞吐被数据库写盘钉死在几百 QPS
   → 50 万请求排队要十几分钟,用户全程盯着转圈 ❌

❌ 纯异步下单:
   写队列 → 立刻返回"已受理"
   → 响应是快了,但用户不知道自己到底抢没抢到,只能反复刷新 ❌

还有一个容易被忽略的事实:秒杀订单的支付本来就是异步的。用户抢到资格之后的动作是”去付款”,付款可能发生在 30 秒后、5 分钟后。把订单创建也做成强同步,并没有换来等价的用户价值——用户要的是”名额保住了”,不是”订单行已经落库”。

所以真正的问题是:同步到哪一步为止。

决策分析

方案响应时间并发能力用户体验实现复杂度
同步下单500ms+1000 QPS★★★★★★☆☆☆☆
异步下单50ms50,000 QPS★★★☆☆★★☆☆☆
混合模式100ms30,000 QPS★★★★☆★★★★☆

我们的选择:混合模式 ✅

结论:同步只做到”确认资格”,落库全部异步。

用户请求
   ↓
Redis Lua 扣减成功(资格到手)
   ↓
写入 Kafka 消息(下单请求)
   ↓
接口立即返回:"您已成功锁定名额,请在 5 分钟内完成支付"
   ↓
消费端异步:幂等校验 → 建订单 → 扣 MySQL 库存 → 推送通知

对照表格里的四个维度:

  • 响应时间 50ms vs 500ms+:主链路上只剩一次 Redis 脚本 + 一次 Kafka 写入,两者都是内存操作和顺序写。
  • 并发能力 50,000 QPS:写队列比写库便宜一个数量级,而且队列可以横向扩容;消费端再按 4.2 节的思路串行化,把并发写压力转成排队。
  • 用户体验 ★★★★☆:比纯同步快 10 倍;比纯异步强在”确定性”——用户立刻拿到明确结果和订单号,不用刷新页面猜。扣一星是因为订单详情要等几十毫秒才能查到。
  • 实现复杂度 ★★★★☆ 是三项里最高的:必须处理消息丢失、重复消费(幂等)、消费失败重试、死信队列、消费积压告警。这些在 6.1 节都展开过,也正是”混合模式”真正的成本所在。

什么时候选另外两种:如果业务允许”抢到后 10 分钟内付款、超时释放”(秒杀商品基本都是这个规则),异步就足够;如果库存极稀缺(比如全场只有 1 件)且必须当场出结果,或者涉及强合规场景(部分票务),可以退回复用”同步 + 限流”的组合,牺牲吞吐换确定性。

如果重来,会改变吗?

不会改变。混合模式是电商行业的标准做法,淘宝、京东都是这样做的。


决策 4:如何限流?🚦

问题

限流的位置决定了防护效果。前面算过一笔账:库存 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 倍是常见起点——太小会误杀真实用户,太大则失去削峰意义。

如果重来,会改变吗?

不会改变。多层限流虽然配置复杂,但在高并发场景下是必不可少的。每一层都有不同的职责,形成纵深防御。


决策 5:缓存策略怎么选?💾

问题

缓存选得对不对,直接决定了主链路上还剩多少数据库压力。

回头看 1.2 节算过的账:一次 3 秒的秒杀里,商品详情、活动配置、商品图片这些数据是完全不变的——活动一开,价格、库存总量、规则就固定了。如果每个请求都去查 MySQL,等于用最贵的介质存最不变的数据:

一次 50 万请求的秒杀期间,典型的读放大:
  商品详情查询   50 万次   ← 数据全程不变,查 1 次就够
  库存查询       50 万次   ← 真正变化的只有 100 次
  活动配置        5 万次   ← 活动开始前配置完就再也不用查

写侧的放大同样致命:扣库存只发生 100 次,但如果每次扣减都要同步更新”商品详情缓存”,就额外产生了 100 次写 + 失效广播 + 集群间同步。

所以要决定的是:哪些数据放哪一层缓存,写路径要不要跟着更新每一层。

决策分析

方案读性能写性能一致性成本
单层 Redis5ms5ms★★★★☆中
多级缓存1ms10ms★★★☆☆低
只本地缓存0.1ms0.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 单层的方案。


决策 6:反欺诈做到什么程度?🔍

问题

第 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,哪些决策需要改变?

点击查看答案

精简方案:

  1. 库存存储:只用 Redis(去掉 MySQL 实时同步)
  2. 限流策略:只用 Nginx 限流
  3. 缓存策略:只用 Redis(去掉本地缓存)
  4. 反欺诈:只用基础方案(限流 + 验证码)
  5. 服务器:全部减半,用更低配置

核心原则:保证核心功能(库存扣减),砍掉辅助功能

问题 2:如果流量是现在的 10 倍,哪些决策需要改变?

点击查看答案

升级方案:

  1. 库存存储:Redis 集群扩容,增加分片
  2. 下单模式:更激进的异步,同步只返回令牌
  3. 限流策略:更严格,提前拦截
  4. 缓存策略:增加 L0 缓存(CPU 缓存级别)
  5. 反欺诈:上机器学习模型,提前识别

核心原则:用空间换时间,用预处理换实时性能

问题 3:这些决策中,哪个最可能后悔?

点击查看答案

可能后悔的:

  1. 多级缓存的一致性维护(容易出 bug)
  2. 混合下单模式的用户通知(容易遗漏)
  3. 反欺诈的误杀处理(用户投诉)

建议:

  • 做好监控和告警
  • 建立快速回滚机制
  • 准备应急预案

发现内容有问题?

告诉我们哪里需要改进。