核心矛盾:大量瞬时流量 vs 极少量库存
六层防护架构:
Layer 1: 客户端防抖(按钮置灰 + 倒计时 + 答题验证码)
│ 拦截30%无效请求
▼
Layer 2: CDN静态化(活动页面CDN缓存,不回源)
│ 拦截60%静态请求
▼
Layer 3: 网关限流(Sentinel/Nginx限流,超出直接拒绝)
│ 拦截超出QPS的请求
▼
Layer 4: Redis Lua扣库存(原子操作,内存级性能)
│ 库存不足直接拒绝
▼
Layer 5: MQ异步下单(消息队列削峰,异步创建订单)
│ 解耦下单与扣库存
▼
Layer 6: DB落库(最终数据持久化,批量写入优化)
│
▼
数据库(乐观锁兜底防超卖)
完整请求链路:
用户下单
│
▼
[Gateway] → 限流检查(令牌桶,库存×1.5倍发放)
│ 通过
▼
[Redis] → Lua脚本原子扣库存
│ 库存充足,扣减成功
▼
[MQ] → 发送订单消息(RocketMQ顺序消息)
│ 立即返回"排队中"
▼
[消费者] → 创建订单 + DB扣库存(乐观锁)
│ 成功
▼
[WebSocket] → 推送支付链接
方案一:Redis DECR(简单场景)
# 初始化库存
SET seckill:stock:1001 100
# 扣减库存(原子操作)
DECR seckill:stock:1001
# 返回值 >= 0 → 扣减成功
# 返回值 < 0 → 库存不足,需要INCR回补
问题:DECR扣到负数后,并发请求都会看到负数
解决:用Lua脚本先检查再扣减
方案二:Redis Lua脚本(推荐)
-- seckill.lua
local stock_key = KEYS[1] -- seckill:stock:1001
local order_key = KEYS[2] -- seckill:orders:1001
local user_id = ARGV[1] -- 用户ID
local quantity = tonumber(ARGV[2]) -- 购买数量
-- 1. 检查是否已购买(防重复)
if redis.call('SISMEMBER', order_key, user_id) == 1 then
return -1 -- 已购买
end
-- 2. 检查库存
local stock = tonumber(redis.call('GET', stock_key) or '0')
if stock < quantity then
return 0 -- 库存不足
end
-- 3. 扣减库存 + 记录已购买(原子操作)
redis.call('DECRBY', stock_key, quantity)
redis.call('SADD', order_key, user_id)
return 1 -- 成功
// Java调用Lua脚本
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public SeckillResult doSeckill(Long userId, Long goodsId, int quantity) {
DefaultRedisScript<Long> script = new DefaultRedisScript<>();
script.setScriptSource(new ResourceScriptSource(
new ClassPathResource("lua/seckill.lua")));
script.setResultType(Long.class);
Long result = redisTemplate.execute(script,
Arrays.asList("seckill:stock:" + goodsId, "seckill:orders:" + goodsId),
userId.toString(), String.valueOf(quantity));
if (result == 1) {
// 发送MQ消息,异步创建订单
rocketMQTemplate.convertAndSend("seckill-order",
new SeckillOrder(userId, goodsId, quantity));
return SeckillResult.queuing();
} else if (result == 0) {
return SeckillResult.soldOut();
} else {
return SeckillResult.duplicate();
}
}
方案三:DB乐观锁(兜底)
-- 方式1:CAS更新
UPDATE seckill_goods
SET stock = stock - #{quantity}
WHERE goods_id = #{goodsId}
AND stock >= #{quantity};
-- affected rows > 0 → 成功
-- affected rows = 0 → 库存不足
-- 方式2:版本号
UPDATE seckill_goods
SET stock = stock - #{quantity}, version = version + 1
WHERE goods_id = #{goodsId}
AND version = #{oldVersion};
三种方案对比:
方案 性能 一致性 复杂度 适用
─────────────────────────────────────────────────
DECR 极高 弱 低 简单场景
Lua脚本 极高 较强 中 生产推荐
DB乐观锁 低 强 低 兜底/小规模
秒杀前(提前30分钟):
┌───────────────────────────────────────────┐
│ 1. 活动信息写入Redis │
│ - 商品信息: seckill:goods:1001 │
│ - 库存数量: seckill:stock:1001 = 100 │
│ - 已购集合: seckill:orders:1001 (Set) │
│ │
│ 2. 活动标记写入本地缓存 │
│ - 避免每次请求查Redis判断是否秒杀商品 │
│ │
│ 3. CDN预热活动页面 │
│ - 静态资源提前推送到边缘节点 │
└───────────────────────────────────────────┘
削峰手段:
1. MQ异步 → 同步变异步
用户 → Redis扣库存 → MQ → 消费者创建订单
响应时间从 200ms → 50ms(只到MQ)
2. 答题/验证码 → 削峰填谷
活动开始瞬间流量 → 分散到几秒/几分钟
3. 分层过滤 → 逐层拦截
100万请求 → CDN挡掉60万 → 网关限流剩10万
→ Redis扣完库存剩1万 → MQ削峰 → DB正常写入
┌─────────────────────────────────────────────────────────────┐
│ 固定窗口 (Fixed Window) │
│ ┌──────────────┐ │
│ │ ████████ 80 │ ← 第一个窗口末尾突发80个请求 │
│ └──────────────┘ │
│ ┌──────────────┐ │
│ │ ████ 40 │ ← 下一个窗口开始又突发40个 │
│ └──────────────┘ │
│ 窗口交界处:80 + 40 = 120,超过阈值100 │
│ 问题:临界点突刺,短时间内2倍流量 │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ 滑动窗口 (Sliding Window) — Sentinel默认 │
│ ┌─────┬─────┬─────┬─────┐ │
│ │ 20 │ 30 │ 25 │ 15 │ 统计 = 20+30+25+15 = 90 │
│ └─────┴─────┴─────┴─────┘ │
│ ← 细粒度格子,滑动统计,解决临界突刺 → │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ 令牌桶 (Token Bucket) │
│ │
│ 令牌以固定速率r生成 ──▶ [||||||||||] ──▶ 请求消耗令牌 │
│ 令牌桶(容量b) │
│ 特点:允许突发(桶内有积累令牌) │
│ 适用:秒杀场景(允许瞬间突发) │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ 漏桶 (Leaky Bucket) │
│ │
│ 请求进入 ──▶ [||||||||||] ──▶ 匀速流出(速率r) │
│ 漏桶(容量b) │
│ 特点:输出绝对匀速,不允许突发 │
│ 适用:保护下游系统(如数据库) │
└─────────────────────────────────────────────────────────────┘
| 算法 | 突发流量 | 匀速输出 | 实现复杂度 | 典型场景 |
|---|---|---|---|---|
| 固定窗口 | 允许(有风险) | 否 | 低 | 简单限流 |
| 滑动窗口 | 较平滑 | 否 | 中 | Sentinel |
| 令牌桶 | 允许 | 否 | 中 | 秒杀入口 |
| 漏桶 | 否 | 是 | 中 | 保护下游 |
1. Redis Lua脚本扣库存,如果Lua执行期间Redis宕机怎么办?
2. 秒杀系统如何保证一个用户只能买一件?
3. 令牌桶和漏桶的核心区别是什么?秒杀场景选哪个?
4. 如果Redis预热的库存和DB不一致(如DB实际只有50件但Redis预热了100),怎么处理?
5. MQ异步下单后,消费者创建订单失败怎么处理?