← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L35 - 秒杀系统设计

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

1. 秒杀系统整体架构

核心矛盾:大量瞬时流量 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] → 推送支付链接

2. 防超卖三种方案

方案一: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乐观锁    低        强         低         兜底/小规模

3. 库存预热


秒杀前(提前30分钟):
  ┌───────────────────────────────────────────┐
  │ 1. 活动信息写入Redis                       │
  │    - 商品信息: seckill:goods:1001          │
  │    - 库存数量: seckill:stock:1001 = 100    │
  │    - 已购集合: seckill:orders:1001 (Set)   │
  │                                           │
  │ 2. 活动标记写入本地缓存                     │
  │    - 避免每次请求查Redis判断是否秒杀商品     │
  │                                           │
  │ 3. CDN预热活动页面                         │
  │    - 静态资源提前推送到边缘节点              │
  └───────────────────────────────────────────┘

4. 流量削峰


削峰手段:
  
  1. MQ异步 → 同步变异步
     用户 → Redis扣库存 → MQ → 消费者创建订单
     响应时间从 200ms → 50ms(只到MQ)
     
  2. 答题/验证码 → 削峰填谷
     活动开始瞬间流量 → 分散到几秒/几分钟
     
  3. 分层过滤 → 逐层拦截
     100万请求 → CDN挡掉60万 → 网关限流剩10万 
     → Redis扣完库存剩1万 → MQ削峰 → DB正常写入

5. 限流算法详解


┌─────────────────────────────────────────────────────────────┐
│ 固定窗口 (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
令牌桶允许否中秒杀入口
漏桶否是中保护下游

面试速记卡(考前30秒速看)

练习题(自测)

1. Redis Lua脚本扣库存,如果Lua执行期间Redis宕机怎么办?

2. 秒杀系统如何保证一个用户只能买一件?

3. 令牌桶和漏桶的核心区别是什么?秒杀场景选哪个?

4. 如果Redis预热的库存和DB不一致(如DB实际只有50件但Redis预热了100),怎么处理?

5. MQ异步下单后,消费者创建订单失败怎么处理?

学习资料