10万并发秒杀系统架构设计方案

10万并发秒杀系统架构设计方案

作者：架构团队
更新时间：2026-01-16
文档类型：架构设计

目录

一、系统概述

1.1 业务场景

秒杀系统是一个典型的高并发、高流量、低库存的电商场景：

业务特征 说明 技术挑战
高并发 10万QPS峰值流量 系统吞吐量、响应时间
低库存 商品数量远小于用户数（如100件商品） 超卖问题、公平性
瞬时流量 流量集中在开始的几秒内 流量削峰、系统稳定性
热点数据 所有请求访问同一商品 缓存击穿、数据库压力
强一致性 库存扣减必须准确 分布式锁、事务一致性

1.2 系统目标

核心指标：
- QPS：支持10万并发请求
- 响应时间：P99 < 200ms
- 可用性：99.99%
- 准确性：0超卖、0少卖
- 用户体验：秒杀成功率 > 1%（假设100件商品，10万人抢）

1.3 技术栈选型

技术分层 技术选型 说明
前端 Vue3 + CDN 静态资源加速
网关 Nginx + OpenResty 限流、缓存、负载均衡
应用层 Spring Boot + Dubbo 微服务架构
缓存层 Redis Cluster 分布式缓存、库存预热
消息队列 RocketMQ 削峰填谷、异步处理
数据库 MySQL 8.0（分库分表） 持久化存储
分布式锁 Redisson 防止超卖
限流降级 Sentinel 流控、熔断
监控 Prometheus + Grafana 实时监控告警

二、核心挑战分析

2.1 高并发读问题

问题： 10万用户同时查询商品详情，数据库扛不住

graph LR A[10万用户] -->|查询商品详情| B[数据库] B -->|崩溃| C[❌ 系统不可用] style A fill:#ffe1e1 style B fill:#ff6b6b style C fill:#ff0000,color:#fff

解决方案： 多级缓存 + CDN

graph LR A[10万用户] -->|1| B[CDN] B -->|命中90%| Z[返回] B -->|未命中10%| C[Nginx本地缓存] C -->|命中8%| Z C -->|未命中2%| D[Redis缓存] D -->|命中1.9%| Z D -->|未命中0.1%| E[数据库] E --> Z style B fill:#e1ffe1 style C fill:#e1f5ff style D fill:#fff4e1

2.2 高并发写问题（核心难点）

问题： 10万用户同时抢100件商品，如何保证不超卖？

场景1：数据库直接扣减（❌ 性能差）

// ❌ 每秒只能处理1000次扣减，远不够
UPDATE seckill_goods SET stock = stock - 1 WHERE id = 1 AND stock > 0;

场景2：应用层加锁（❌ 单点瓶颈）

// ❌ 所有请求串行化，QPS极低
synchronized (this) {
    if (stock > 0) {
        stock--;
    }
}

场景3：Redis + Lua脚本（✅ 推荐）

-- ✅ Redis单线程，原子性操作，QPS可达10万+
local stock = redis.call('get', KEYS[1])
if tonumber(stock) > 0 then
    redis.call('decr', KEYS[1])
    return 1
else
    return 0
end

2.3 流量削峰问题

问题： 瞬时10万请求涌入，后端系统撑不住

graph TD A[秒杀开始<br/>10万QPS] -->|直接打到后端| B[应用服务器] B -->|压力过大| C[❌ 服务崩溃] style A fill:#ffe1e1 style C fill:#ff0000,color:#fff

解决方案： 消息队列削峰

graph TD A[秒杀开始<br/>10万QPS] -->|限流后1万QPS| B[消息队列] B -->|平稳消费<br/>5000QPS| C[应用服务器] C -->|处理订单| D[✅ 系统稳定] style A fill:#fff4e1 style B fill:#e1f5ff style D fill:#e1ffe1

2.4 热点数据问题

问题： 所有请求访问同一个Redis Key，单个Redis节点压力过大

graph LR A[10万请求] -->|都访问stock:1001| B[Redis单节点] B -->|CPU 100%| C[❌ 性能瓶颈] style B fill:#ff6b6b

解决方案： 本地缓存 + 分段库存

graph TD A[10万请求] -->|负载均衡| B1[应用1<br/>本地缓存1000件] A -->|负载均衡| B2[应用2<br/>本地缓存1000件] A -->|负载均衡| B3[应用3<br/>本地缓存1000件] B1 -->|内存扣减| D[无需访问Redis] B2 -->|内存扣减| D B3 -->|内存扣减| D style B1 fill:#e1ffe1 style B2 fill:#e1ffe1 style B3 fill:#e1ffe1

三、整体架构设计

3.1 系统分层架构

graph TB subgraph 用户层 A1[PC端] A2[H5端] A3[APP端] end subgraph 接入层 B1[CDN静态资源] B2[Nginx网关<br/>限流/缓存] B3[API Gateway<br/>鉴权/路由] end subgraph 应用层 C1[秒杀服务<br/>库存扣减] C2[订单服务<br/>订单创建] C3[支付服务<br/>支付处理] C4[用户服务<br/>用户验证] end subgraph 缓存层 D1[Redis Cluster<br/>热点数据] D2[本地缓存<br/>Caffeine] end subgraph 消息层 E1[RocketMQ<br/>削峰填谷] end subgraph 数据层 F1[MySQL主从<br/>订单库] F2[MySQL主从<br/>库存库] end A1 --> B1 A2 --> B1 A3 --> B1 B1 --> B2 B2 --> B3 B3 --> C1 B3 --> C2 B3 --> C3 B3 --> C4 C1 --> D1 C1 --> D2 C1 --> E1 C2 --> E1 E1 --> C2 C1 --> F2 C2 --> F1 style C1 fill:#ffe1e1 style D1 fill:#fff4e1 style E1 fill:#e1f5ff

3.2 核心业务流程

sequenceDiagram participant U as 用户 participant N as Nginx participant S as 秒杀服务 participant R as Redis participant MQ as RocketMQ participant O as 订单服务 participant DB as MySQL U->>N: 1. 点击秒杀按钮 N->>N: 2. 限流（令牌桶） alt 限流通过 N->>S: 3. 请求秒杀 S->>S: 4. 验证用户身份 S->>S: 5. 检查是否重复抢购 S->>R: 6. Lua脚本扣减库存 alt 扣减成功 R-->>S: 7. 返回成功 S->>MQ: 8. 发送订单消息 S-->>U: 9. 返回"秒杀成功，正在生成订单" MQ->>O: 10. 消费消息，创建订单 O->>DB: 11. 写入订单表 DB-->>O: 12. 订单创建完成 O->>R: 13. 更新订单缓存 O-->>U: 14. 推送订单详情 else 扣减失败 R-->>S: 库存不足 S-->>U: 返回"商品已售罄" end else 限流拒绝 N-->>U: 返回"请求过于频繁" end

四、核心技术方案

4.1 前端优化

4.1.1 页面静态化

<!-- 商品详情页完全静态化，部署到CDN -->
<!DOCTYPE html>
<html>
<head>
    <title>iPhone 15 Pro秒杀</title>
    <!-- CSS静态资源 -->
    <link rel="stylesheet" href="https://cdn.example.com/css/seckill.css">
</head>
<body>
    <div id="product">
        <h1>iPhone 15 Pro</h1>
        <p>秒杀价：￥5999</p>
        <p>原价：￥7999</p>
        
        <!-- 倒计时（纯前端JS） -->
        <div id="countdown">距离开始还有：<span id="time"></span></div>
        
        <!-- 秒杀按钮 -->
        <button id="seckill-btn" onclick="doSeckill()" disabled>
            立即抢购
        </button>
    </div>
    
    <script src="https://cdn.example.com/js/seckill.js"></script>
    <script>
        // 倒计时逻辑（纯前端）
        let startTime = new Date('2026-01-20 20:00:00').getTime();
        
        setInterval(() => {
            let now = new Date().getTime();
            let diff = startTime - now;
            
            if (diff <= 0) {
                document.getElementById('seckill-btn').disabled = false;
                document.getElementById('countdown').innerHTML = '秒杀进行中';
            } else {
                let seconds = Math.floor(diff / 1000);
                document.getElementById('time').innerHTML = seconds + '秒';
            }
        }, 1000);
        
        // 秒杀请求
        function doSeckill() {
            // 1. 按钮置灰（防止重复点击）
            let btn = document.getElementById('seckill-btn');
            btn.disabled = true;
            btn.innerHTML = '抢购中...';
            
            // 2. 发送秒杀请求
            fetch('/api/seckill/buy', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': 'Bearer ' + getToken()
                },
                body: JSON.stringify({
                    goodsId: 1001,
                    userId: getUserId(),
                    timestamp: Date.now()
                })
            })
            .then(response => response.json())
            .then(data => {
                if (data.code === 200) {
                    alert('秒杀成功！正在生成订单...');
                    // 跳转到订单页
                    window.location.href = '/order/' + data.orderId;
                } else {
                    alert(data.message);
                    btn.disabled = false;
                    btn.innerHTML = '立即抢购';
                }
            })
            .catch(error => {
                alert('网络异常，请重试');
                btn.disabled = false;
                btn.innerHTML = '立即抢购';
            });
        }
    </script>
</body>
</html>

优势：

  • ✅ 静态资源走CDN，减轻服务器压力
  • ✅ 倒计时等逻辑纯前端实现，无需请求后端
  • ✅ 按钮置灰防止重复点击

4.1.2 防刷限制

/**
 * 前端防刷策略
 */
class SeckillProtection {
    constructor() {
        this.clickCount = 0;
        this.lastClickTime = 0;
        this.maxClickPerSecond = 1; // 每秒最多点击1次
    }
    
    /**
     * 检查是否允许点击
     */
    canClick() {
        let now = Date.now();
        
        // 1秒内点击次数限制
        if (now - this.lastClickTime < 1000) {
            if (this.clickCount >= this.maxClickPerSecond) {
                alert('您的手速太快了，请稍后再试');
                return false;
            }
            this.clickCount++;
        } else {
            this.clickCount = 1;
        }
        
        this.lastClickTime = now;
        return true;
    }
    
    /**
     * 生成请求签名（防止接口被刷）
     */
    generateSign(params) {
        // 将参数排序
        let keys = Object.keys(params).sort();
        let str = '';
        for (let key of keys) {
            str += key + '=' + params[key] + '&';
        }
        
        // 加上密钥
        str += 'secret=YOUR_SECRET_KEY';
        
        // MD5签名
        return md5(str);
    }
}

// 使用示例
let protection = new SeckillProtection();

function doSeckill() {
    if (!protection.canClick()) {
        return;
    }
    
    let params = {
        goodsId: 1001,
        userId: getUserId(),
        timestamp: Date.now()
    };
    
    // 添加签名
    params.sign = protection.generateSign(params);
    
    // 发送请求...
}

4.2 Nginx层优化

4.2.1 Nginx配置

# nginx.conf
http {
    # 1. 限流配置
    limit_req_zone $binary_remote_addr zone=seckill_limit:10m rate=10r/s;
    limit_req_zone $server_name zone=server_limit:10m rate=10000r/s;
    
    # 2. 本地缓存配置
    proxy_cache_path /data/nginx/cache levels=1:2 keys_zone=seckill_cache:100m 
                     max_size=1g inactive=10m use_temp_path=off;
    
    upstream seckill_servers {
        # 一致性哈希（同一用户请求到同一台服务器）
        hash $request_uri consistent;
        
        server 192.168.1.101:8080 weight=1 max_fails=2 fail_timeout=30s;
        server 192.168.1.102:8080 weight=1 max_fails=2 fail_timeout=30s;
        server 192.168.1.103:8080 weight=1 max_fails=2 fail_timeout=30s;
        
        # 长连接
        keepalive 256;
    }
    
    server {
        listen 80;
        server_name seckill.example.com;
        
        # 静态资源直接返回
        location ~* \.(jpg|jpeg|png|gif|css|js)$ {
            root /data/static;
            expires 7d;
            access_log off;
        }
        
        # 秒杀接口
        location /api/seckill/ {
            # 限流（每个IP每秒最多10个请求）
            limit_req zone=seckill_limit burst=20 nodelay;
            
            # 服务器总限流（每秒最多1万个请求）
            limit_req zone=server_limit burst=5000 nodelay;
            
            # 本地缓存（商品详情等接口）
            proxy_cache seckill_cache;
            proxy_cache_valid 200 10m;
            proxy_cache_key "$request_uri";
            
            # 代理到后端
            proxy_pass http://seckill_servers;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            
            # 超时设置
            proxy_connect_timeout 3s;
            proxy_send_timeout 5s;
            proxy_read_timeout 5s;
        }
        
        # 健康检查
        location /health {
            access_log off;
            return 200 "ok";
        }
    }
}

核心功能：

  1. 限流： 防止单个用户刷接口，保护后端服务
  2. 本地缓存： 商品详情等热点数据缓存在Nginx，减少后端压力
  3. 负载均衡： 一致性哈希，同一用户请求到同一台服务器
  4. 长连接： keepalive减少连接建立开销

4.2.2 OpenResty + Lua（高级）

-- lua/seckill.lua
local redis = require "resty.redis"
local cjson = require "cjson"

-- 连接Redis
local red = redis:new()
red:set_timeout(1000)

local ok, err = red:connect("127.0.0.1", 6379)
if not ok then
    ngx.log(ngx.ERR, "failed to connect redis: ", err)
    return ngx.exit(500)
end

-- 获取请求参数
local goodsId = ngx.var.arg_goodsId
local userId = ngx.var.arg_userId

-- 检查用户是否已经秒杀过（防止重复抢购）
local userKey = "seckill:user:" .. userId .. ":" .. goodsId
local hasSeized = red:exists(userKey)

if hasSeized == 1 then
    ngx.say(cjson.encode({code = 400, message = "您已经抢购过了"}))
    return ngx.exit(200)
end

-- Lua脚本扣减库存
local stockKey = "seckill:stock:" .. goodsId
local script = [[
    local stock = redis.call('get', KEYS[1])
    if tonumber(stock) > 0 then
        redis.call('decr', KEYS[1])
        return 1
    else
        return 0
    end
]]

local result = red:eval(script, 1, stockKey)

if result == 1 then
    -- 扣减成功，记录用户已抢购
    red:setex(userKey, 86400, 1)
    
    -- 发送MQ消息（调用后端接口）
    ngx.say(cjson.encode({code = 200, message = "秒杀成功"}))
else
    ngx.say(cjson.encode({code = 400, message = "商品已售罄"}))
end

-- 关闭Redis连接
red:close()

nginx配置：

location /api/seckill/buy {
    content_by_lua_file /usr/local/openresty/lua/seckill.lua;
}

优势：

  • ✅ 性能极高： 在Nginx层直接用Lua操作Redis，QPS可达10万+
  • ✅ 减少网络开销： 无需转发到Java应用
  • ✅ 降低后端压力： 库存扣减在Nginx层完成

4.3 应用层核心实现

4.3.1 秒杀服务主流程

/**
 * 秒杀服务
 */
@Service
@Slf4j
public class SeckillService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private RedissonClient redisson;
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Autowired
    private SeckillGoodsMapper seckillGoodsMapper;
    
    @Autowired
    private UserService userService;
    
    /**
     * 秒杀抢购（核心方法）
     */
    public SeckillResult doSeckill(Long userId, Long goodsId) {
        // ===== 1. 参数校验 =====
        if (userId == null || goodsId == null) {
            return SeckillResult.fail("参数错误");
        }
        
        // ===== 2. 检查秒杀活动是否开始 =====
        String activityKey = "seckill:activity:" + goodsId;
        SeckillActivity activity = (SeckillActivity) redisTemplate.opsForValue().get(activityKey);
        
        if (activity == null) {
            return SeckillResult.fail("活动不存在");
        }
        
        long now = System.currentTimeMillis();
        if (now < activity.getStartTime()) {
            return SeckillResult.fail("活动未开始");
        }
        if (now > activity.getEndTime()) {
            return SeckillResult.fail("活动已结束");
        }
        
        // ===== 3. 检查用户是否已经秒杀过（防止重复抢购） =====
        String userKey = "seckill:user:" + userId + ":" + goodsId;
        Boolean hasSeized = redisTemplate.hasKey(userKey);
        if (Boolean.TRUE.equals(hasSeized)) {
            return SeckillResult.fail("您已经抢购过了");
        }
        
        // ===== 4. 扣减库存（核心） =====
        boolean success = deductStock(goodsId);
        if (!success) {
            return SeckillResult.fail("商品已售罄");
        }
        
        // ===== 5. 记录用户已抢购（防止重复） =====
        redisTemplate.opsForValue().set(userKey, 1, 24, TimeUnit.HOURS);
        
        // ===== 6. 生成订单号 =====
        String orderId = generateOrderId(userId, goodsId);
        
        // ===== 7. 发送MQ消息，异步创建订单 =====
        SeckillOrderMessage message = SeckillOrderMessage.builder()
                .orderId(orderId)
                .userId(userId)
                .goodsId(goodsId)
                .timestamp(System.currentTimeMillis())
                .build();
        
        try {
            rocketMQTemplate.syncSend("seckill-order-topic", message, 3000);
            log.info("发送订单消息成功: orderId={}", orderId);
        } catch (Exception e) {
            log.error("发送订单消息失败，回滚库存: orderId={}", orderId, e);
            // 回滚库存
            rollbackStock(goodsId);
            return SeckillResult.fail("系统繁忙，请重试");
        }
        
        // ===== 8. 返回结果 =====
        return SeckillResult.success(orderId, "秒杀成功，正在生成订单");
    }
    
    /**
     * 扣减库存（Redis + Lua脚本保证原子性）
     */
    private boolean deductStock(Long goodsId) {
        String stockKey = "seckill:stock:" + goodsId;
        
        // Lua脚本（原子操作）
        String luaScript = 
            "local stock = redis.call('get', KEYS[1]) " +
            "if tonumber(stock) > 0 then " +
            "    redis.call('decr', KEYS[1]) " +
            "    return 1 " +
            "else " +
            "    return 0 " +
            "end";
        
        // 执行Lua脚本
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(stockKey)
        );
        
        return result != null && result == 1;
    }
    
    /**
     * 回滚库存
     */
    private void rollbackStock(Long goodsId) {
        String stockKey = "seckill:stock:" + goodsId;
        redisTemplate.opsForValue().increment(stockKey);
        log.warn("回滚库存: goodsId={}", goodsId);
    }
    
    /**
     * 生成订单号（雪花算法）
     */
    private String generateOrderId(Long userId, Long goodsId) {
        // 使用雪花算法生成唯一订单号
        long timestamp = System.currentTimeMillis();
        return "SK" + timestamp + userId + goodsId + RandomUtils.nextInt(1000, 9999);
    }
}

4.3.2 订单服务（MQ消费者）

/**
 * 订单消息消费者
 */
@Component
@RocketMQMessageListener(
    topic = "seckill-order-topic",
    consumerGroup = "seckill-order-consumer-group",
    consumeMode = ConsumeMode.ORDERLY, // 顺序消费
    maxReconsumeTimes = 3
)
@Slf4j
public class SeckillOrderConsumer implements RocketMQListener<SeckillOrderMessage> {
    
    @Autowired
    private SeckillOrderMapper orderMapper;
    
    @Autowired
    private SeckillGoodsMapper goodsMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void onMessage(SeckillOrderMessage message) {
        log.info("收到秒杀订单消息: {}", message);
        
        String orderId = message.getOrderId();
        Long userId = message.getUserId();
        Long goodsId = message.getGoodsId();
        
        try {
            // ===== 1. 查询商品信息 =====
            SeckillGoods goods = goodsMapper.selectById(goodsId);
            if (goods == null) {
                log.error("商品不存在: goodsId={}", goodsId);
                return;
            }
            
            // ===== 2. 创建订单（写入数据库） =====
            SeckillOrder order = new SeckillOrder();
            order.setOrderId(orderId);
            order.setUserId(userId);
            order.setGoodsId(goodsId);
            order.setGoodsName(goods.getGoodsName());
            order.setGoodsPrice(goods.getSeckillPrice());
            order.setQuantity(1);
            order.setTotalAmount(goods.getSeckillPrice());
            order.setStatus(OrderStatus.UNPAID.getCode());
            order.setCreateTime(new Date());
            
            orderMapper.insert(order);
            log.info("订单创建成功: orderId={}", orderId);
            
            // ===== 3. 扣减数据库库存（最终一致性） =====
            int rows = goodsMapper.deductStock(goodsId, 1);
            if (rows == 0) {
                log.error("数据库库存不足，订单创建失败: goodsId={}", goodsId);
                // 标记订单为失败状态
                order.setStatus(OrderStatus.FAILED.getCode());
                orderMapper.updateById(order);
                
                // 回滚Redis库存
                String stockKey = "seckill:stock:" + goodsId;
                redisTemplate.opsForValue().increment(stockKey);
                return;
            }
            
            // ===== 4. 写入订单缓存 =====
            String orderKey = "seckill:order:" + orderId;
            redisTemplate.opsForValue().set(orderKey, order, 30, TimeUnit.MINUTES);
            
            // ===== 5. 发送订单创建成功通知（推送给用户） =====
            // 可以通过WebSocket、短信、Push等方式通知用户
            notifyUser(userId, orderId);
            
            log.info("订单处理完成: orderId={}", orderId);
            
        } catch (Exception e) {
            log.error("处理订单异常: orderId={}", orderId, e);
            // 抛出异常，触发RocketMQ重试机制
            throw new RuntimeException("订单处理失败", e);
        }
    }
    
    /**
     * 通知用户订单创建成功
     */
    private void notifyUser(Long userId, String orderId) {
        // 实现方式：WebSocket、短信、APP推送等
        log.info("通知用户订单创建成功: userId={}, orderId={}", userId, orderId);
    }
}

4.3.3 库存预热

/**
 * 秒杀活动预热服务
 */
@Service
@Slf4j
public class SeckillPreheatService {
    
    @Autowired
    private SeckillGoodsMapper goodsMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 预热秒杀活动
     * 在秒杀开始前1小时执行
     */
    public void preheatSeckillActivity(Long goodsId) {
        log.info("开始预热秒杀活动: goodsId={}", goodsId);
        
        // 1. 查询商品信息
        SeckillGoods goods = goodsMapper.selectById(goodsId);
        if (goods == null) {
            throw new BusinessException("商品不存在");
        }
        
        // 2. 商品信息写入Redis（商品详情）
        String goodsKey = "seckill:goods:" + goodsId;
        redisTemplate.opsForValue().set(goodsKey, goods, 2, TimeUnit.HOURS);
        log.info("商品信息写入Redis: goodsKey={}", goodsKey);
        
        // 3. 库存写入Redis（核心）
        String stockKey = "seckill:stock:" + goodsId;
        redisTemplate.opsForValue().set(stockKey, goods.getStock());
        log.info("库存写入Redis: stockKey={}, stock={}", stockKey, goods.getStock());
        
        // 4. 活动信息写入Redis
        SeckillActivity activity = new SeckillActivity();
        activity.setGoodsId(goodsId);
        activity.setStartTime(goods.getStartTime().getTime());
        activity.setEndTime(goods.getEndTime().getTime());
        
        String activityKey = "seckill:activity:" + goodsId;
        redisTemplate.opsForValue().set(activityKey, activity, 2, TimeUnit.HOURS);
        log.info("活动信息写入Redis: activityKey={}", activityKey);
        
        // 5. 设置库存监控（库存不足时告警）
        setupStockMonitor(goodsId, goods.getStock());
        
        log.info("秒杀活动预热完成: goodsId={}", goodsId);
    }
    
    /**
     * 库存监控
     */
    private void setupStockMonitor(Long goodsId, Integer totalStock) {
        String stockKey = "seckill:stock:" + goodsId;
        
        // 启动定时任务监控库存
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            try {
                Object stockObj = redisTemplate.opsForValue().get(stockKey);
                if (stockObj != null) {
                    int stock = Integer.parseInt(stockObj.toString());
                    
                    // 计算售罄比例
                    double ratio = (double) (totalStock - stock) / totalStock * 100;
                    log.info("库存监控: goodsId={}, 剩余库存={}, 售罄比例={:.2f}%", 
                            goodsId, stock, ratio);
                    
                    // 库存不足10%时告警
                    if (stock > 0 && ratio > 90) {
                        log.warn("库存告警：商品即将售罄！goodsId={}, 剩余库存={}", goodsId, stock);
                    }
                    
                    // 库存为0时停止监控
                    if (stock <= 0) {
                        log.info("商品已售罄，停止监控: goodsId={}", goodsId);
                        scheduler.shutdown();
                    }
                }
            } catch (Exception e) {
                log.error("库存监控异常", e);
            }
        }, 0, 5, TimeUnit.SECONDS); // 每5秒检查一次
    }
}

4.4 Redis方案详解

4.4.1 Redis数据结构设计

/**
 * Redis Key设计规范
 */
public class SeckillRedisKeys {
    
    // 商品详情：Hash结构
    // Key: seckill:goods:{goodsId}
    // Value: {name, price, image, desc}
    public static final String GOODS_KEY = "seckill:goods:%d";
    
    // 库存：String结构（支持原子递减）
    // Key: seckill:stock:{goodsId}
    // Value: 库存数量
    public static final String STOCK_KEY = "seckill:stock:%d";
    
    // 活动信息：Hash结构
    // Key: seckill:activity:{goodsId}
    // Value: {startTime, endTime, status}
    public static final String ACTIVITY_KEY = "seckill:activity:%d";
    
    // 用户抢购记录：Set结构（判断用户是否已抢购）
    // Key: seckill:user:{userId}:{goodsId}
    // Value: 1
    public static final String USER_KEY = "seckill:user:%d:%d";
    
    // 订单信息：Hash结构
    // Key: seckill:order:{orderId}
    // Value: {userId, goodsId, status, createTime}
    public static final String ORDER_KEY = "seckill:order:%s";
    
    // 分布式锁（防止超卖）
    // Key: seckill:lock:{goodsId}
    public static final String LOCK_KEY = "seckill:lock:%d";
}

4.4.2 Lua脚本（原子性保证）

/**
 * Redis Lua脚本管理
 */
@Component
public class SeckillLuaScripts {
    
    /**
     * 扣减库存（检查库存+扣减+检查是否重复抢购）
     */
    public static final String DEDUCT_STOCK_SCRIPT = 
        "-- 参数：KEYS[1]=库存Key, KEYS[2]=用户Key, ARGV[1]=过期时间(秒) \n" +
        "-- 检查用户是否已抢购 \n" +
        "local hasSeized = redis.call('exists', KEYS[2]) \n" +
        "if hasSeized == 1 then \n" +
        "    return -1  -- 已经抢购过 \n" +
        "end \n" +
        "\n" +
        "-- 检查库存并扣减 \n" +
        "local stock = redis.call('get', KEYS[1]) \n" +
        "if tonumber(stock) > 0 then \n" +
        "    redis.call('decr', KEYS[1]) \n" +
        "    redis.call('setex', KEYS[2], ARGV[1], 1) \n" +
        "    return 1  -- 扣减成功 \n" +
        "else \n" +
        "    return 0  -- 库存不足 \n" +
        "end";
    
    /**
     * 回滚库存（增加库存+删除用户记录）
     */
    public static final String ROLLBACK_STOCK_SCRIPT = 
        "-- 参数：KEYS[1]=库存Key, KEYS[2]=用户Key \n" +
        "redis.call('incr', KEYS[1]) \n" +
        "redis.call('del', KEYS[2]) \n" +
        "return 1";
    
    /**
     * 批量预热库存
     */
    public static final String PREHEAT_STOCK_SCRIPT = 
        "-- 参数：KEYS[1]=库存Key, ARGV[1]=库存数量, ARGV[2]=过期时间 \n" +
        "redis.call('set', KEYS[1], ARGV[1], 'EX', ARGV[2]) \n" +
        "return 1";
}

/**
 * 使用Lua脚本的秒杀服务
 */
@Service
public class SeckillServiceWithLua {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 扣减库存（Lua脚本）
     */
    public int deductStockWithLua(Long goodsId, Long userId) {
        String stockKey = String.format(SeckillRedisKeys.STOCK_KEY, goodsId);
        String userKey = String.format(SeckillRedisKeys.USER_KEY, userId, goodsId);
        
        // 执行Lua脚本
        DefaultRedisScript<Long> script = new DefaultRedisScript<>();
        script.setScriptText(SeckillLuaScripts.DEDUCT_STOCK_SCRIPT);
        script.setResultType(Long.class);
        
        Long result = redisTemplate.execute(
            script,
            Arrays.asList(stockKey, userKey),
            86400 // 用户记录过期时间24小时
        );
        
        if (result == null) {
            return 0;
        }
        
        return result.intValue();
    }
}

4.4.3 Redis集群部署

# Redis Cluster配置（3主3从）
spring:
  redis:
    cluster:
      nodes:
        - 192.168.1.101:6379  # 主节点1
        - 192.168.1.102:6379  # 主节点2
        - 192.168.1.103:6379  # 主节点3
        - 192.168.1.104:6379  # 从节点1
        - 192.168.1.105:6379  # 从节点2
        - 192.168.1.106:6379  # 从节点3
      max-redirects: 3
    lettuce:
      pool:
        max-active: 200    # 最大连接数
        max-idle: 50       # 最大空闲连接
        min-idle: 10       # 最小空闲连接
        max-wait: 3000ms   # 最大等待时间
    timeout: 3000ms

为什么用Redis Cluster？

对比项 单机Redis 主从Redis Redis Cluster
QPS ~10万 ~10万（读写分离可达20万） ~50万+（水平扩展）
可用性 ❌ 单点故障 ✅ 主从切换 ✅ 自动故障转移
容量 受单机内存限制 受单机内存限制 ✅ 可水平扩展
适用场景 测试环境 中小型系统 ✅ 秒杀系统（推荐）

4.5 消息队列方案

4.5.1 RocketMQ配置

# application.yml
rocketmq:
  name-server: 192.168.1.201:9876;192.168.1.202:9876
  producer:
    group: seckill-producer-group
    send-message-timeout: 3000
    retry-times-when-send-failed: 2
    max-message-size: 4194304  # 4MB
  consumer:
    group: seckill-order-consumer-group
    consume-thread-min: 20
    consume-thread-max: 50

4.5.2 消息发送与消费

/**
 * 秒杀订单消息
 */
@Data
@Builder
public class SeckillOrderMessage {
    private String orderId;
    private Long userId;
    private Long goodsId;
    private Long timestamp;
}

/**
 * 消息生产者
 */
@Service
public class SeckillMessageProducer {
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    /**
     * 发送订单消息（同步发送，确保消息不丢失）
     */
    public boolean sendOrderMessage(SeckillOrderMessage message) {
        try {
            SendResult sendResult = rocketMQTemplate.syncSend(
                "seckill-order-topic",
                MessageBuilder.withPayload(message).build(),
                3000 // 3秒超时
            );
            
            if (sendResult.getSendStatus() == SendStatus.SEND_OK) {
                log.info("发送订单消息成功: msgId={}, orderId={}", 
                        sendResult.getMsgId(), message.getOrderId());
                return true;
            } else {
                log.error("发送订单消息失败: status={}, orderId={}", 
                        sendResult.getSendStatus(), message.getOrderId());
                return false;
            }
        } catch (Exception e) {
            log.error("发送订单消息异常: orderId={}", message.getOrderId(), e);
            return false;
        }
    }
    
    /**
     * 发送延时消息（订单超时未支付自动取消）
     */
    public void sendDelayOrderCancelMessage(String orderId, int delayMinutes) {
        OrderCancelMessage message = new OrderCancelMessage();
        message.setOrderId(orderId);
        message.setTimestamp(System.currentTimeMillis());
        
        // RocketMQ延时级别：1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
        // 30分钟 = 延时级别16
        int delayLevel = 16;
        
        rocketMQTemplate.syncSend(
            "order-cancel-topic",
            MessageBuilder.withPayload(message).build(),
            3000,
            delayLevel
        );
        
        log.info("发送订单取消延时消息: orderId={}, delayMinutes={}", orderId, delayMinutes);
    }
}

五、详细设计与实现

5.1 防止超卖方案对比

方案1：数据库乐观锁 ⭐⭐

/**
 * 乐观锁扣减库存
 */
@Mapper
public interface SeckillGoodsMapper {
    
    @Update("UPDATE seckill_goods " +
            "SET stock = stock - 1, version = version + 1 " +
            "WHERE id = #{goodsId} AND stock > 0 AND version = #{version}")
    int deductStockWithVersion(@Param("goodsId") Long goodsId, 
                               @Param("version") Integer version);
}

// 使用
public boolean deductStock(Long goodsId) {
    SeckillGoods goods = goodsMapper.selectById(goodsId);
    int rows = goodsMapper.deductStockWithVersion(goodsId, goods.getVersion());
    return rows > 0;
}

优点： 实现简单
缺点： 性能差（每次都要查询数据库），高并发下大量失败重试

方案2：数据库悲观锁 ⭐⭐

@Update("UPDATE seckill_goods " +
        "SET stock = stock - 1 " +
        "WHERE id = #{goodsId} AND stock > 0 " +
        "FOR UPDATE")
int deductStockWithLock(@Param("goodsId") Long goodsId);

优点： 绝对不会超卖
缺点： 性能极差（行锁阻塞），不适合高并发

方案3：Redis + Lua脚本 ⭐⭐⭐⭐⭐

local stock = redis.call('get', KEYS[1])
if tonumber(stock) > 0 then
    redis.call('decr', KEYS[1])
    return 1
else
    return 0
end

优点：

  • ✅ 性能极高（单Redis QPS 10万+）
  • ✅ 原子性保证（Lua脚本在Redis中是原子执行）
  • ✅ 无锁设计（Redis单线程）

缺点：

  • ❌ Redis宕机会丢失数据（需要主从+持久化）

方案4：Redis + 分布式锁 ⭐⭐⭐⭐

public boolean deductStockWithLock(Long goodsId) {
    String lockKey = "seckill:lock:" + goodsId;
    RLock lock = redisson.getLock(lockKey);
    
    try {
        // 尝试获取锁，最多等待0秒，锁自动释放时间10秒
        if (lock.tryLock(0, 10, TimeUnit.SECONDS)) {
            // 检查库存
            String stockKey = "seckill:stock:" + goodsId;
            Integer stock = (Integer) redisTemplate.opsForValue().get(stockKey);
            
            if (stock != null && stock > 0) {
                // 扣减库存
                redisTemplate.opsForValue().decrement(stockKey);
                return true;
            }
            return false;
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        lock.unlock();
    }
    
    return false;
}

优点： 分布式环境下绝对不会超卖
缺点： 性能比Lua脚本差（需要加锁解锁），但仍然可以达到几万QPS

方案5：本地内存 + 分段库存 ⭐⭐⭐⭐⭐

/**
 * 本地内存扣减库存（性能最高）
 */
@Service
public class LocalStockService {
    
    // 本地库存（每个应用实例分配一部分库存）
    private AtomicInteger localStock = new AtomicInteger(0);
    
    /**
     * 初始化本地库存
     * 假设总库存10000件，10台机器，每台分配1000件
     */
    @PostConstruct
    public void initLocalStock() {
        Long goodsId = 1001L;
        String stockKey = "seckill:stock:" + goodsId;
        
        // 从Redis获取一批库存到本地
        Long stock = redisTemplate.opsForValue().increment(stockKey, -1000);
        if (stock != null && stock >= 0) {
            localStock.set(1000);
            log.info("初始化本地库存成功: localStock=1000");
        } else {
            log.warn("Redis库存不足，无法初始化本地库存");
        }
    }
    
    /**
     * 本地扣减库存（性能极高，无网络开销）
     */
    public boolean deductLocalStock() {
        int current = localStock.get();
        while (current > 0) {
            if (localStock.compareAndSet(current, current - 1)) {
                return true;
            }
            current = localStock.get();
        }
        return false;
    }
}

优点：

  • ✅ 性能最高： 纯内存操作，QPS可达百万级
  • ✅ 无网络开销： 不需要访问Redis
  • ✅ 减轻Redis压力： 热点Key问题解决

缺点：

  • ❌ 库存分配不均（某些机器库存用完，其他机器还有）
  • ❌ 机器宕机会损失库存（可通过健康检查回收）

5.2 幂等性保证

/**
 * 幂等性保证
 */
@Service
public class SeckillIdempotentService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 检查请求是否重复（基于请求Token）
     */
    public boolean checkIdempotent(String token) {
        if (StringUtils.isBlank(token)) {
            return false;
        }
        
        String key = "seckill:token:" + token;
        
        // 使用Redis的SETNX命令（原子操作）
        Boolean success = redisTemplate.opsForValue().setIfAbsent(
            key, 
            1, 
            5, 
            TimeUnit.MINUTES
        );
        
        return Boolean.TRUE.equals(success);
    }
    
    /**
     * 生成幂等Token（前端请求时携带）
     */
    public String generateToken(Long userId, Long goodsId) {
        String data = userId + ":" + goodsId + ":" + System.currentTimeMillis();
        return DigestUtils.md5DigestAsHex(data.getBytes());
    }
}

/**
 * 秒杀接口（带幂等性校验）
 */
@RestController
@RequestMapping("/api/seckill")
public class SeckillController {
    
    @Autowired
    private SeckillService seckillService;
    
    @Autowired
    private SeckillIdempotentService idempotentService;
    
    @PostMapping("/buy")
    public Result<String> buy(@RequestBody SeckillRequest request) {
        // 1. 幂等性校验
        if (!idempotentService.checkIdempotent(request.getToken())) {
            return Result.fail("请勿重复提交");
        }
        
        // 2. 执行秒杀
        SeckillResult result = seckillService.doSeckill(
            request.getUserId(), 
            request.getGoodsId()
        );
        
        return Result.success(result.getOrderId());
    }
}

5.3 微服务架构下的秒杀方案 ★★★★★

在实际生产环境中，订单服务和库存服务通常是分离的。这种架构下实现秒杀面临更大挑战。

5.3.1 微服务架构挑战

graph TB A[秒杀服务] -->|1. 扣减库存| B[库存服务] A -->|2. 创建订单| C[订单服务] B -->|成功| D{创建订单} B -->|失败| E[库存不足] D -->|成功| F[秒杀成功] D -->|失败| G[回滚库存] style B fill:#ffe1e1 style C fill:#e1f5ff style G fill:#ff6b6b

核心问题：

  1. ❌ 分布式事务： 库存扣减成功，订单创建失败怎么办？
  2. ❌ 网络延迟： 跨服务调用增加响应时间
  3. ❌ 服务依赖： 库存服务挂了，秒杀就不可用
  4. ❌ 数据一致性： 如何保证库存和订单的一致性？

5.3.2 方案对比

方案 一致性 性能 复杂度 推荐度
Seata分布式事务 强一致 ⭐⭐ 差 ⭐⭐⭐⭐ 高 ⭐⭐
TCC补偿事务 最终一致 ⭐⭐⭐ 中 ⭐⭐⭐⭐⭐ 极高 ⭐⭐⭐
本地消息表 最终一致 ⭐⭐⭐⭐ 好 ⭐⭐⭐ 中 ⭐⭐⭐⭐
RocketMQ事务消息 最终一致 ⭐⭐⭐⭐ 好 ⭐⭐⭐ 中 ⭐⭐⭐⭐⭐
Saga模式 最终一致 ⭐⭐⭐⭐ 好 ⭐⭐⭐⭐ 高 ⭐⭐⭐⭐

5.3.3 推荐方案：RocketMQ事务消息 + 本地消息表

架构设计：

sequenceDiagram participant U as 用户 participant S as 秒杀服务 participant R as Redis participant MQ as RocketMQ participant IS as 库存服务 participant OS as 订单服务 participant DB as 订单DB U->>S: 1. 秒杀请求 S->>R: 2. Lua脚本扣减Redis库存 R-->>S: 3. 扣减成功 S->>MQ: 4. 发送Half消息（预扣库存） MQ-->>S: 5. Half消息发送成功 S->>DB: 6. 创建本地订单记录（PENDING） DB-->>S: 7. 订单创建成功 S->>MQ: 8. 提交事务消息 MQ->>IS: 9. 投递消息：扣减库存 IS->>IS: 10. 扣减数据库库存 IS-->>MQ: 11. 消费成功 MQ->>OS: 12. 投递消息：创建订单 OS->>OS: 13. 创建订单记录 OS-->>MQ: 14. 消费成功 OS-->>U: 15. 推送订单详情

5.3.4 完整实现代码

A. 秒杀服务（发送事务消息）
/**
 * 秒杀服务（微服务架构）
 */
@Service
@Slf4j
public class SeckillServiceForMicroservice {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Autowired
    private SeckillOrderMapper seckillOrderMapper;
    
    /**
     * 秒杀抢购（微服务版本）
     */
    public SeckillResult doSeckill(Long userId, Long goodsId) {
        // ===== 1. 参数校验（同前面的实现） =====
        if (userId == null || goodsId == null) {
            return SeckillResult.fail("参数错误");
        }
        
        // ===== 2. 检查活动、防止重复抢购（同前面的实现） =====
        // ...省略代码...
        
        // ===== 3. 扣减Redis库存 =====
        boolean success = deductStock(goodsId);
        if (!success) {
            return SeckillResult.fail("商品已售罄");
        }
        
        // ===== 4. 生成订单号 =====
        String orderId = generateOrderId(userId, goodsId);
        
        // ===== 5. 发送RocketMQ事务消息 =====
        SeckillOrderMessage message = SeckillOrderMessage.builder()
                .orderId(orderId)
                .userId(userId)
                .goodsId(goodsId)
                .timestamp(System.currentTimeMillis())
                .build();
        
        try {
            // 发送事务消息（Half消息）
            TransactionSendResult sendResult = rocketMQTemplate.sendMessageInTransaction(
                "seckill-tx-group",           // 事务组
                "seckill-order-topic",        // Topic
                MessageBuilder.withPayload(message).build(),
                message                        // 传递给本地事务执行器的参数
            );
            
            if (sendResult.getLocalTransactionState() == LocalTransactionState.COMMIT_MESSAGE) {
                log.info("秒杀成功: orderId={}", orderId);
                return SeckillResult.success(orderId, "秒杀成功，正在生成订单");
            } else {
                log.error("本地事务执行失败，回滚库存: orderId={}", orderId);
                rollbackStock(goodsId);
                return SeckillResult.fail("系统繁忙，请重试");
            }
            
        } catch (Exception e) {
            log.error("发送事务消息失败: orderId={}", orderId, e);
            rollbackStock(goodsId);
            return SeckillResult.fail("系统繁忙，请重试");
        }
    }
    
    /**
     * 扣减Redis库存
     */
    private boolean deductStock(Long goodsId) {
        String stockKey = "seckill:stock:" + goodsId;
        
        String luaScript = 
            "local stock = redis.call('get', KEYS[1]) " +
            "if tonumber(stock) > 0 then " +
            "    redis.call('decr', KEYS[1]) " +
            "    return 1 " +
            "else " +
            "    return 0 " +
            "end";
        
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Collections.singletonList(stockKey)
        );
        
        return result != null && result == 1;
    }
    
    /**
     * 回滚库存
     */
    private void rollbackStock(Long goodsId) {
        String stockKey = "seckill:stock:" + goodsId;
        redisTemplate.opsForValue().increment(stockKey);
        log.warn("回滚库存: goodsId={}", goodsId);
    }
    
    /**
     * 生成订单号
     */
    private String generateOrderId(Long userId, Long goodsId) {
        long timestamp = System.currentTimeMillis();
        return "SK" + timestamp + userId + goodsId + RandomUtils.nextInt(1000, 9999);
    }
}
B. 本地事务监听器
/**
 * RocketMQ事务消息监听器
 */
@Component
@RocketMQTransactionListener(txProducerGroup = "seckill-tx-group")
@Slf4j
public class SeckillTransactionListener implements RocketMQLocalTransactionListener {
    
    @Autowired
    private SeckillOrderMapper seckillOrderMapper;
    
    @Autowired
    private SeckillGoodsMapper seckillGoodsMapper;
    
    /**
     * 执行本地事务（Half消息发送成功后调用）
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        SeckillOrderMessage message = (SeckillOrderMessage) arg;
        String orderId = message.getOrderId();
        
        log.info("执行本地事务: orderId={}", orderId);
        
        try {
            // ===== 1. 查询商品信息 =====
            SeckillGoods goods = seckillGoodsMapper.selectById(message.getGoodsId());
            if (goods == null) {
                log.error("商品不存在: goodsId={}", message.getGoodsId());
                return RocketMQLocalTransactionState.ROLLBACK;
            }
            
            // ===== 2. 创建本地订单记录（状态：PENDING） =====
            SeckillOrder order = new SeckillOrder();
            order.setOrderId(orderId);
            order.setUserId(message.getUserId());
            order.setGoodsId(message.getGoodsId());
            order.setGoodsName(goods.getGoodsName());
            order.setGoodsPrice(goods.getSeckillPrice());
            order.setQuantity(1);
            order.setTotalAmount(goods.getSeckillPrice());
            order.setStatus(OrderStatus.PENDING.getCode());  // PENDING状态
            order.setCreateTime(new Date());
            
            int rows = seckillOrderMapper.insert(order);
            
            if (rows > 0) {
                log.info("本地订单创建成功: orderId={}", orderId);
                // 提交事务消息（消息会被投递到库存服务和订单服务）
                return RocketMQLocalTransactionState.COMMIT;
            } else {
                log.error("本地订单创建失败: orderId={}", orderId);
                return RocketMQLocalTransactionState.ROLLBACK;
            }
            
        } catch (Exception e) {
            log.error("本地事务执行异常: orderId={}", orderId, e);
            // 返回UNKNOWN，RocketMQ会回查事务状态
            return RocketMQLocalTransactionState.UNKNOWN;
        }
    }
    
    /**
     * 回查本地事务状态（当本地事务返回UNKNOWN时调用）
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        MessageExt messageExt = (MessageExt) msg;
        String body = new String(messageExt.getBody());
        SeckillOrderMessage message = JSON.parseObject(body, SeckillOrderMessage.class);
        String orderId = message.getOrderId();
        
        log.info("回查本地事务状态: orderId={}", orderId);
        
        try {
            // 查询本地订单记录
            SeckillOrder order = seckillOrderMapper.selectByOrderId(orderId);
            
            if (order != null) {
                log.info("订单已存在，提交事务: orderId={}", orderId);
                return RocketMQLocalTransactionState.COMMIT;
            } else {
                log.warn("订单不存在，回滚事务: orderId={}", orderId);
                return RocketMQLocalTransactionState.ROLLBACK;
            }
            
        } catch (Exception e) {
            log.error("回查本地事务异常: orderId={}", orderId, e);
            // 继续返回UNKNOWN，RocketMQ会再次回查
            return RocketMQLocalTransactionState.UNKNOWN;
        }
    }
}
C. 库存服务（消费者）
/**
 * 库存服务 - 扣减库存消费者
 */
@Component
@RocketMQMessageListener(
    topic = "seckill-order-topic",
    consumerGroup = "stock-deduct-consumer-group",
    consumeMode = ConsumeMode.ORDERLY,
    maxReconsumeTimes = 3
)
@Slf4j
public class StockDeductConsumer implements RocketMQListener<SeckillOrderMessage> {
    
    @Autowired
    private StockMapper stockMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void onMessage(SeckillOrderMessage message) {
        String orderId = message.getOrderId();
        Long goodsId = message.getGoodsId();
        
        log.info("库存服务收到扣减库存消息: orderId={}, goodsId={}", orderId, goodsId);
        
        try {
            // ===== 1. 幂等性检查（防止重复扣减） =====
            String key = "stock:deduct:" + orderId;
            Boolean exists = redisTemplate.hasKey(key);
            if (Boolean.TRUE.equals(exists)) {
                log.warn("库存已扣减，跳过: orderId={}", orderId);
                return;
            }
            
            // ===== 2. 扣减数据库库存 =====
            int rows = stockMapper.deductStock(goodsId, 1);
            
            if (rows > 0) {
                log.info("数据库库存扣减成功: orderId={}, goodsId={}", orderId, goodsId);
                
                // 记录已扣减标记（24小时过期）
                redisTemplate.opsForValue().set(key, 1, 24, TimeUnit.HOURS);
                
                // ===== 3. 发送库存扣减成功事件 =====
                publishStockDeductedEvent(orderId, goodsId);
                
            } else {
                log.error("数据库库存不足: orderId={}, goodsId={}", orderId, goodsId);
                
                // ===== 4. 库存不足，发送补偿消息 =====
                publishStockInsufficientEvent(orderId, goodsId);
                
                // 抛出异常，触发重试
                throw new BusinessException("数据库库存不足");
            }
            
        } catch (Exception e) {
            log.error("扣减库存异常: orderId={}", orderId, e);
            throw new RuntimeException("扣减库存失败", e);
        }
    }
    
    /**
     * 发布库存扣减成功事件
     */
    private void publishStockDeductedEvent(String orderId, Long goodsId) {
        // 发送MQ消息通知订单服务
        StockDeductedEvent event = new StockDeductedEvent();
        event.setOrderId(orderId);
        event.setGoodsId(goodsId);
        event.setTimestamp(System.currentTimeMillis());
        
        rocketMQTemplate.asyncSend("stock-deducted-topic", event, null);
    }
    
    /**
     * 发布库存不足事件（补偿）
     */
    private void publishStockInsufficientEvent(String orderId, Long goodsId) {
        StockInsufficientEvent event = new StockInsufficientEvent();
        event.setOrderId(orderId);
        event.setGoodsId(goodsId);
        
        rocketMQTemplate.asyncSend("stock-insufficient-topic", event, null);
    }
}
D. 订单服务（消费者）
/**
 * 订单服务 - 创建订单消费者
 */
@Component
@RocketMQMessageListener(
    topic = "seckill-order-topic",
    consumerGroup = "order-create-consumer-group",
    consumeMode = ConsumeMode.ORDERLY,
    maxReconsumeTimes = 3
)
@Slf4j
public class OrderCreateConsumer implements RocketMQListener<SeckillOrderMessage> {
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private GoodsMapper goodsMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void onMessage(SeckillOrderMessage message) {
        String orderId = message.getOrderId();
        Long userId = message.getUserId();
        Long goodsId = message.getGoodsId();
        
        log.info("订单服务收到创建订单消息: orderId={}", orderId);
        
        try {
            // ===== 1. 幂等性检查 =====
            Order existOrder = orderMapper.selectByOrderId(orderId);
            if (existOrder != null) {
                log.warn("订单已存在，跳过: orderId={}", orderId);
                return;
            }
            
            // ===== 2. 查询商品信息 =====
            SeckillGoods goods = goodsMapper.selectById(goodsId);
            if (goods == null) {
                log.error("商品不存在: goodsId={}", goodsId);
                return;
            }
            
            // ===== 3. 创建订单 =====
            Order order = new Order();
            order.setOrderId(orderId);
            order.setUserId(userId);
            order.setGoodsId(goodsId);
            order.setGoodsName(goods.getGoodsName());
            order.setGoodsPrice(goods.getSeckillPrice());
            order.setQuantity(1);
            order.setTotalAmount(goods.getSeckillPrice());
            order.setStatus(OrderStatus.UNPAID.getCode());  // 未支付
            order.setCreateTime(new Date());
            
            orderMapper.insert(order);
            log.info("订单创建成功: orderId={}", orderId);
            
            // ===== 4. 写入订单缓存 =====
            String orderKey = "order:" + orderId;
            redisTemplate.opsForValue().set(orderKey, order, 30, TimeUnit.MINUTES);
            
            // ===== 5. 发送订单创建成功通知 =====
            notifyUser(userId, orderId);
            
        } catch (Exception e) {
            log.error("创建订单异常: orderId={}", orderId, e);
            throw new RuntimeException("创建订单失败", e);
        }
    }
    
    /**
     * 通知用户订单创建成功
     */
    private void notifyUser(Long userId, String orderId) {
        // WebSocket/短信/Push推送
        log.info("通知用户订单创建成功: userId={}, orderId={}", userId, orderId);
    }
}
E. 补偿机制（库存不足时回滚）
/**
 * 库存不足补偿消费者
 */
@Component
@RocketMQMessageListener(
    topic = "stock-insufficient-topic",
    consumerGroup = "stock-insufficient-consumer-group"
)
@Slf4j
public class StockInsufficientCompensateConsumer implements RocketMQListener<StockInsufficientEvent> {
    
    @Autowired
    private SeckillOrderMapper seckillOrderMapper;
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public void onMessage(StockInsufficientEvent event) {
        String orderId = event.getOrderId();
        Long goodsId = event.getGoodsId();
        
        log.warn("收到库存不足事件，开始补偿: orderId={}, goodsId={}", orderId, goodsId);
        
        try {
            // ===== 1. 取消秒杀服务的本地订单 =====
            SeckillOrder seckillOrder = seckillOrderMapper.selectByOrderId(orderId);
            if (seckillOrder != null) {
                seckillOrder.setStatus(OrderStatus.FAILED.getCode());
                seckillOrderMapper.updateById(seckillOrder);
                log.info("取消秒杀服务本地订单: orderId={}", orderId);
            }
            
            // ===== 2. 取消订单服务的订单 =====
            Order order = orderMapper.selectByOrderId(orderId);
            if (order != null) {
                order.setStatus(OrderStatus.CANCELLED.getCode());
                orderMapper.updateById(order);
                log.info("取消订单服务订单: orderId={}", orderId);
            }
            
            // ===== 3. 回滚Redis库存 =====
            String stockKey = "seckill:stock:" + goodsId;
            redisTemplate.opsForValue().increment(stockKey);
            log.info("回滚Redis库存: goodsId={}", goodsId);
            
            // ===== 4. 删除用户抢购记录（允许重新抢购） =====
            if (seckillOrder != null) {
                String userKey = "seckill:user:" + seckillOrder.getUserId() + ":" + goodsId;
                redisTemplate.delete(userKey);
                log.info("删除用户抢购记录: userKey={}", userKey);
            }
            
            // ===== 5. 通知用户秒杀失败 =====
            if (seckillOrder != null) {
                notifyUserFailed(seckillOrder.getUserId(), orderId);
            }
            
        } catch (Exception e) {
            log.error("补偿处理异常: orderId={}", orderId, e);
        }
    }
    
    /**
     * 通知用户秒杀失败
     */
    private void notifyUserFailed(Long userId, String orderId) {
        log.info("通知用户秒杀失败: userId={}, orderId={}", userId, orderId);
    }
}

5.3.5 方案优势

相比单体架构的优势：

对比项 单体架构 微服务架构
服务隔离 ❌ 全部耦合在一起 ✅ 订单/库存服务独立
扩展性 ❌ 整体扩展 ✅ 按需扩展某个服务
容错性 ❌ 一处故障全部不可用 ✅ 服务降级，部分可用
数据一致性 ✅ 本地事务 ⚠️ 最终一致性（需要额外保证）
性能 ✅ 无网络调用 ⚠️ 有网络延迟

方案特点：

  • ✅ 最终一致性保证： RocketMQ事务消息 + 补偿机制
  • ✅ 高性能： Redis快速扣减 + 异步处理
  • ✅ 高可用： 服务独立，互不影响
  • ✅ 可追溯： 本地订单记录 + MQ消息日志
  • ✅ 幂等性： Redis标记 + 数据库唯一索引

5.3.6 故障处理流程

graph TD A[秒杀请求] --> B{Redis扣减库存} B -->|成功| C[发送Half消息] B -->|失败| Z1[返回库存不足] C --> D{本地事务} D -->|成功| E[提交消息] D -->|失败| F[回滚消息] E --> G[库存服务消费] G --> H{扣减DB库存} H -->|成功| I[订单服务创建订单] H -->|失败| J[发送补偿消息] J --> K[取消订单] K --> L[回滚Redis库存] L --> M[删除用户抢购记录] M --> N[通知用户失败] F --> L I --> Z2[秒杀完成] N --> Z3[用户可重新抢购] style H fill:#ffe1e1 style J fill:#ff6b6b style L fill:#fff4e1

5.3.7 监控告警

/**
 * 微服务秒杀监控
 */
@Component
public class MicroserviceSeckillMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    /**
     * 监控Redis库存与DB库存差异
     */
    @Scheduled(fixedRate = 60000) // 每分钟检查一次
    public void checkStockConsistency() {
        Long goodsId = 1001L;
        
        // Redis库存
        String stockKey = "seckill:stock:" + goodsId;
        Integer redisStock = (Integer) redisTemplate.opsForValue().get(stockKey);
        
        // DB库存
        Integer dbStock = stockMapper.getStock(goodsId);
        
        if (redisStock != null && dbStock != null) {
            int diff = Math.abs(redisStock - dbStock);
            
            // 差异超过10，告警
            if (diff > 10) {
                log.error("库存不一致！Redis={}, DB={}, 差异={}", redisStock, dbStock, diff);
                alertService.send("库存不一致告警：Redis=" + redisStock + ", DB=" + dbStock);
            }
        }
    }
    
    /**
     * 监控订单创建成功率
     */
    @Scheduled(fixedRate = 60000)
    public void checkOrderSuccessRate() {
        // 查询最近1分钟的订单创建情况
        long totalOrders = orderMapper.countRecentOrders(60);
        long successOrders = orderMapper.countSuccessOrders(60);
        
        double successRate = totalOrders > 0 ? (double) successOrders / totalOrders * 100 : 0;
        
        log.info("订单成功率: {:.2f}% (成功={}, 总数={})", successRate, successOrders, totalOrders);
        
        // 成功率低于80%，告警
        if (successRate < 80) {
            alertService.send("订单成功率过低：" + successRate + "%");
        }
    }
}

5.3.8 降级策略

/**
 * 微服务降级策略
 */
@Service
public class MicroserviceDegradeService {
    
    @Autowired
    private StockServiceFeignClient stockServiceFeignClient;
    
    /**
     * 调用库存服务（带降级）
     */
    @HystrixCommand(
        fallbackMethod = "deductStockFallback",
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        }
    )
    public boolean deductStock(Long goodsId, Integer quantity) {
        // 调用库存服务
        return stockServiceFeignClient.deductStock(goodsId, quantity);
    }
    
    /**
     * 降级方法：库存服务不可用时
     */
    public boolean deductStockFallback(Long goodsId, Integer quantity, Throwable throwable) {
        log.error("库存服务不可用，触发降级: goodsId={}", goodsId, throwable);
        
        // 降级策略1：直接返回失败
        return false;
        
        // 降级策略2：使用本地库存（如果有）
        // return localStockService.deductStock(goodsId, quantity);
    }
}

5.4 限流降级

5.4.1 Sentinel限流配置

/**
 * Sentinel限流配置
 */
@Configuration
public class SentinelConfig {
    
    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        // 规则1：秒杀接口限流（QPS=10000）
        FlowRule rule1 = new FlowRule();
        rule1.setResource("seckill-buy");
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setCount(10000);  // 每秒最多1万个请求
        rule1.setLimitApp("default");
        rule1.setStrategy(RuleConstant.STRATEGY_DIRECT);
        rule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule1);
        
        // 规则2：订单查询接口限流（QPS=5000）
        FlowRule rule2 = new FlowRule();
        rule2.setResource("order-query");
        rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule2.setCount(5000);
        rules.add(rule2);
        
        FlowRuleManager.loadRules(rules);
        
        log.info("Sentinel限流规则加载完成");
    }
    
    /**
     * 降级规则
     */
    @PostConstruct
    public void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();
        
        // 降级规则：慢调用比例（RT > 200ms的请求超过50%，触发降级）
        DegradeRule rule = new DegradeRule();
        rule.setResource("seckill-buy");
        rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
        rule.setCount(200);  // RT阈值200ms
        rule.setTimeWindow(10);  // 降级时长10秒
        rule.setMinRequestAmount(10);  // 最小请求数
        rule.setSlowRatioThreshold(0.5);  // 慢调用比例50%
        rules.add(rule);
        
        DegradeRuleManager.loadRules(rules);
    }
}

5.4.2 限流注解使用

@RestController
@RequestMapping("/api/seckill")
public class SeckillController {
    
    /**
     * 秒杀接口（限流+降级）
     */
    @PostMapping("/buy")
    @SentinelResource(
        value = "seckill-buy",
        blockHandler = "handleBlock",  // 限流处理
        fallback = "handleFallback"     // 降级处理
    )
    public Result<String> buy(@RequestBody SeckillRequest request) {
        return seckillService.doSeckill(request.getUserId(), request.getGoodsId());
    }
    
    /**
     * 限流处理（被Sentinel限流时调用）
     */
    public Result<String> handleBlock(SeckillRequest request, BlockException ex) {
        log.warn("请求被限流: userId={}, goodsId={}", request.getUserId(), request.getGoodsId());
        return Result.fail("系统繁忙，请稍后再试");
    }
    
    /**
     * 降级处理（系统异常时调用）
     */
    public Result<String> handleFallback(SeckillRequest request, Throwable ex) {
        log.error("系统异常，触发降级: userId={}", request.getUserId(), ex);
        return Result.fail("服务暂时不可用，请稍后再试");
    }
}

六、性能优化方案

6.1 数据库优化

6.1.1 表结构设计

-- 秒杀商品表
CREATE TABLE seckill_goods (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    goods_name VARCHAR(200) NOT NULL COMMENT '商品名称',
    goods_image VARCHAR(500) COMMENT '商品图片',
    original_price DECIMAL(10,2) NOT NULL COMMENT '原价',
    seckill_price DECIMAL(10,2) NOT NULL COMMENT '秒杀价',
    stock INT NOT NULL DEFAULT 0 COMMENT '库存',
    start_time DATETIME NOT NULL COMMENT '开始时间',
    end_time DATETIME NOT NULL COMMENT '结束时间',
    status TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0待开始 1进行中 2已结束',
    version INT NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_start_time (start_time),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀商品表';

-- 秒杀订单表（分库分表）
CREATE TABLE seckill_order (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_id VARCHAR(64) NOT NULL COMMENT '订单号',
    user_id BIGINT NOT NULL COMMENT '用户ID',
    goods_id BIGINT NOT NULL COMMENT '商品ID',
    goods_name VARCHAR(200) NOT NULL COMMENT '商品名称',
    goods_price DECIMAL(10,2) NOT NULL COMMENT '商品价格',
    quantity INT NOT NULL DEFAULT 1 COMMENT '数量',
    total_amount DECIMAL(10,2) NOT NULL COMMENT '总金额',
    status TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0未支付 1已支付 2已取消 3已完成',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    pay_time DATETIME COMMENT '支付时间',
    INDEX idx_order_id (order_id),
    INDEX idx_user_id (user_id),
    INDEX idx_goods_id (goods_id),
    INDEX idx_create_time (create_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀订单表';

6.1.2 分库分表策略

# ShardingSphere配置
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2,ds3
      
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://192.168.1.101:3306/seckill_order_0
        username: root
        password: password
      
      ds1:
        jdbc-url: jdbc:mysql://192.168.1.102:3306/seckill_order_1
      
      ds2:
        jdbc-url: jdbc:mysql://192.168.1.103:3306/seckill_order_2
      
      ds3:
        jdbc-url: jdbc:mysql://192.168.1.104:3306/seckill_order_3
    
    rules:
      sharding:
        tables:
          seckill_order:
            # 分库策略：按user_id取模分4个库
            database-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: database-mod
            
            # 分表策略：每个库16张表，按order_id取模
            table-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: table-mod
            
            # 实际节点
            actual-data-nodes: ds${0..3}.seckill_order_${0..15}
        
        sharding-algorithms:
          database-mod:
            type: MOD
            props:
              sharding-count: 4
          
          table-mod:
            type: HASH_MOD
            props:
              sharding-count: 16

为什么要分库分表？

  • 单表数据量： 秒杀订单量巨大，单表容易超过千万级
  • 写入压力： 分散到多个数据库，提高并发写入能力
  • 查询性能： 根据user_id查询时，直接定位到某个库某张表

6.2 JVM优化

# JVM启动参数（8核16G服务器）
java -jar seckill-service.jar \
  -Xms8g \                      # 初始堆大小8G
  -Xmx8g \                      # 最大堆大小8G
  -Xmn4g \                      # 年轻代4G
  -XX:MetaspaceSize=256m \      # 元空间256M
  -XX:MaxMetaspaceSize=512m \   # 最大元空间512M
  -XX:+UseG1GC \                # 使用G1垃圾回收器
  -XX:MaxGCPauseMillis=200 \    # 最大GC停顿时间200ms
  -XX:+HeapDumpOnOutOfMemoryError \  # OOM时dump堆
  -XX:HeapDumpPath=/data/logs/heapdump.hprof \
  -Xloggc:/data/logs/gc.log \   # GC日志
  -XX:+PrintGCDetails \
  -XX:+PrintGCDateStamps

6.3 连接池优化

# HikariCP配置（MySQL连接池）
spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      maximum-pool-size: 200        # 最大连接数
      minimum-idle: 50              # 最小空闲连接
      connection-timeout: 30000     # 连接超时30秒
      idle-timeout: 600000          # 空闲超时10分钟
      max-lifetime: 1800000         # 最大生命周期30分钟
      connection-test-query: SELECT 1

# Lettuce配置（Redis连接池）
spring:
  redis:
    lettuce:
      pool:
        max-active: 200   # 最大连接数
        max-idle: 50      # 最大空闲连接
        min-idle: 10      # 最小空闲连接
        max-wait: 3000ms  # 最大等待时间

七、高可用保障

7.1 服务降级策略

/**
 * 降级开关
 */
@Component
public class SeckillDegradeSwitch {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 检查是否需要降级
     */
    public boolean shouldDegrade() {
        String key = "seckill:degrade:switch";
        Object value = redisTemplate.opsForValue().get(key);
        return "1".equals(String.valueOf(value));
    }
    
    /**
     * 开启降级（通过运维后台触发）
     */
    public void enableDegrade() {
        redisTemplate.opsForValue().set("seckill:degrade:switch", "1");
        log.warn("秒杀系统降级已开启");
    }
    
    /**
     * 关闭降级
     */
    public void disableDegrade() {
        redisTemplate.delete("seckill:degrade:switch");
        log.info("秒杀系统降级已关闭");
    }
}

/**
 * 秒杀服务（带降级）
 */
@Service
public class SeckillServiceWithDegrade {
    
    @Autowired
    private SeckillDegradeSwitch degradeSwitch;
    
    public SeckillResult doSeckill(Long userId, Long goodsId) {
        // 降级检查
        if (degradeSwitch.shouldDegrade()) {
            return SeckillResult.fail("系统繁忙，请稍后再试");
        }
        
        // 正常秒杀流程...
    }
}

7.2 熔断机制

/**
 * Hystrix熔断配置
 */
@Configuration
public class HystrixConfig {
    
    @Bean
    public HystrixCommandProperties.Setter hystrixProperties() {
        return HystrixCommandProperties.Setter()
            // 熔断器开启阈值（10秒内失败50%）
            .withCircuitBreakerRequestVolumeThreshold(20)
            .withCircuitBreakerErrorThresholdPercentage(50)
            .withCircuitBreakerSleepWindowInMilliseconds(5000)  // 熔断5秒
            
            // 超时设置
            .withExecutionTimeoutInMilliseconds(3000)  // 3秒超时
            
            // 线程池隔离
            .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD);
    }
}

7.3 多机房部署

graph TB subgraph 北京机房 A1[Nginx] --> A2[应用服务器*10] A2 --> A3[Redis Cluster] A2 --> A4[MySQL主从] end subgraph 上海机房 B1[Nginx] --> B2[应用服务器*10] B2 --> B3[Redis Cluster] B2 --> B4[MySQL主从] end subgraph 广州机房 C1[Nginx] --> C2[应用服务器*10] C2 --> C3[Redis Cluster] C2 --> C4[MySQL主从] end DNS[DNS智能解析] --> A1 DNS --> B1 DNS --> C1 A3 -.同步.-> B3 B3 -.同步.-> C3 A4 -.主从复制.-> B4 B4 -.主从复制.-> C4

八、监控与运维

8.1 监控指标

/**
 * 秒杀监控指标
 */
@Component
public class SeckillMetrics {
    
    private final Counter seckillRequestCounter;
    private final Counter seckillSuccessCounter;
    private final Counter seckillFailCounter;
    private final Histogram seckillDurationHistogram;
    
    public SeckillMetrics(MeterRegistry registry) {
        // 请求总数
        this.seckillRequestCounter = Counter.builder("seckill.request.total")
                .description("秒杀请求总数")
                .register(registry);
        
        // 成功数
        this.seckillSuccessCounter = Counter.builder("seckill.success.total")
                .description("秒杀成功总数")
                .register(registry);
        
        // 失败数
        this.seckillFailCounter = Counter.builder("seckill.fail.total")
                .description("秒杀失败总数")
                .register(registry);
        
        // 响应时间分布
        this.seckillDurationHistogram = Histogram.builder("seckill.duration")
                .description("秒杀请求响应时间")
                .register(registry);
    }
    
    public void recordRequest() {
        seckillRequestCounter.increment();
    }
    
    public void recordSuccess() {
        seckillSuccessCounter.increment();
    }
    
    public void recordFail() {
        seckillFailCounter.increment();
    }
    
    public void recordDuration(long durationMs) {
        seckillDurationHistogram.record(durationMs);
    }
}

8.2 Grafana监控大盘

# Prometheus配置
scrape_configs:
  - job_name: 'seckill-service'
    scrape_interval: 5s
    static_configs:
      - targets: 
        - '192.168.1.101:8080'
        - '192.168.1.102:8080'
        - '192.168.1.103:8080'
    metrics_path: '/actuator/prometheus'

核心监控指标：

指标 告警阈值 说明
QPS > 12万（超出容量20%） 请求速率
响应时间P99 > 200ms 99%请求的响应时间
错误率 > 5% 失败请求占比
Redis命中率 < 90% 缓存效率
MQ积压 > 10万条消息 消息堆积
CPU使用率 > 80% 服务器负载
内存使用率 > 85% 内存压力
JVM GC时间 > 1秒 GC停顿

九、性能评估与瓶颈分析

9.1 10万QPS压力评估 ★★★★★

核心问题：如果10万请求全部压在后端，能否撑得住？

9.1.1 各组件性能上限分析

graph LR A[10万QPS请求] -->|限流| B[Nginx网关] B -->|转发| C[应用服务器集群] C -->|读写| D[Redis Cluster] C -->|查询| E[MySQL集群] C -->|发送消息| F[RocketMQ] B -.性能上限<br/>单机2万QPS.-> B C -.性能上限<br/>单机5000QPS.-> C D -.性能上限<br/>单节点10万QPS.-> D E -.性能上限<br/>单机3000QPS.-> E F -.性能上限<br/>单机10万TPS.-> F style B fill:#fff4e1 style C fill:#ffe1e1 style D fill:#e1ffe1 style E fill:#ff6b6b style F fill:#e1f5ff

9.1.2 瓶颈分析表

组件 单机性能 所需机器数 实际配置 是否充足 瓶颈点
Nginx 2万QPS 5台 5台 ✅ 刚好够 网络带宽
应用服务器 5000 QPS 20台 20台 ✅ 刚好够 CPU、线程池
Redis Cluster 单节点10万QPS 1主节点即可 3主3从 ✅ 性能过剩 网络IO
MySQL 3000 QPS（写） 无法支撑10万写 4主4从 ❌ 严重瓶颈 磁盘IO
RocketMQ 10万TPS 1台 3台 ✅ 性能充足 网络IO

结论：

❌ 如果10万请求全部打到后端，MySQL会成为最大瓶颈！
✅ 但秒杀系统设计了多层拦截，实际到达MySQL的请求极少

9.1.3 详细性能分析

A. Nginx网关层

单机性能测试：

# 测试环境：8核16G
# wrk压测工具
wrk -t12 -c1000 -d30s http://nginx-server/api/seckill/buy

# 测试结果：
Requests/sec:  20,536.42      # 单机QPS：2万
Latency:       48.67ms         # 平均响应时间
Transfer/sec:  5.12MB

瓶颈分析：

CPU使用率：75%        ✅ 不是瓶颈
内存使用率：45%       ✅ 不是瓶颈
网络带宽：800Mbps     ⚠️ 接近瓶颈（千兆网卡）
磁盘IO：基本无        ✅ 不是瓶颈

扩容方案：

10万QPS ÷ 2万QPS/台 = 5台Nginx
建议配置：5台 + 1台备用 = 6台
B. 应用服务器层（核心瓶颈）

单机性能测试：

// 测试环境：8核16G，Tomcat默认配置
// 压测接口：/api/seckill/buy

// 测试结果：
QPS：5,247              # 单机QPS：5000左右
平均响应时间：191ms
P99响应时间：278ms
CPU使用率：85%
内存使用率：62%

代码层面瓶颈：

public SeckillResult doSeckill(Long userId, Long goodsId) {
    // ===== 性能消耗分析 =====
    
    // 1. 参数校验（1ms）✅ 不是瓶颈
    if (userId == null || goodsId == null) {
        return SeckillResult.fail("参数错误");
    }
    
    // 2. Redis查询活动信息（3-5ms）✅ 可接受
    SeckillActivity activity = redisTemplate.opsForValue().get(activityKey);
    
    // 3. Redis检查重复抢购（3-5ms）✅ 可接受
    Boolean hasSeized = redisTemplate.hasKey(userKey);
    
    // 4. Redis Lua脚本扣减库存（5-8ms）✅ 可接受
    boolean success = deductStock(goodsId);
    
    // 5. Redis记录用户已抢购（3-5ms）✅ 可接受
    redisTemplate.opsForValue().set(userKey, 1, 24, TimeUnit.HOURS);
    
    // 6. 发送MQ消息（10-15ms）⚠️ 相对耗时
    rocketMQTemplate.syncSend("seckill-order-topic", message, 3000);
    
    // 总耗时：25-40ms（理想情况）
    // 实际QPS：1000ms ÷ 40ms = 25,000 QPS（单线程）
    
    // 但Tomcat默认线程池：200个线程
    // 实际QPS：200 * 25 = 5,000 QPS（接近测试结果）
}

线程池调优：

# application.yml
server:
  tomcat:
    threads:
      max: 500              # 最大线程数（从200增加到500）
      min-spare: 100        # 最小空闲线程
    max-connections: 10000  # 最大连接数
    accept-count: 1000      # 等待队列长度

调优后性能：

单机QPS：8,000左右（提升60%）
所需机器数：10万QPS ÷ 8000QPS = 13台（留20%余量 = 16台）
C. Redis Cluster层（性能过剩）

单节点性能测试：

# Redis官方benchmark
redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 1000000 -d 1024

# 测试结果：
GET:  120,482.89 requests/sec    # 读操作12万QPS
SET:  115,074.80 requests/sec    # 写操作11.5万QPS
INCR: 121,654.50 requests/sec    # 自增12万QPS

实际压测（Lua脚本）：

# 测试Lua脚本扣减库存
redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 1000000 \
  --script "local stock = redis.call('get', KEYS[1]); 
            if tonumber(stock) > 0 then 
              redis.call('decr', KEYS[1]); 
              return 1; 
            else 
              return 0; 
            end"

# 测试结果：
QPS：98,765 requests/sec          # 单节点接近10万QPS

瓶颈分析：

CPU使用率：45%        ✅ 不是瓶颈（Redis单线程，单核45%很正常）
内存使用率：15%       ✅ 不是瓶颈
网络带宽：600Mbps     ⚠️ 可能成为瓶颈
磁盘IO：基本无        ✅ 不是瓶颈（数据在内存）

结论：

单个Redis主节点即可支撑10万QPS！
配置3主3从是为了：
1. 高可用（主节点挂了自动切换）
2. 读写分离（从节点分担读压力）
3. 数据备份（从节点备份数据）
D. MySQL数据库层（最大瓶颈）❌

单机写入性能测试：

-- 测试环境：16核64G，SSD硬盘
-- 测试场景：INSERT订单表

-- 测试脚本
DELIMITER $$
CREATE PROCEDURE insert_test()
BEGIN
  DECLARE i INT DEFAULT 0;
  WHILE i < 100000 DO
    INSERT INTO seckill_order (order_id, user_id, goods_id, ...) 
    VALUES (CONCAT('SK', i), i, 1001, ...);
    SET i = i + 1;
  END WHILE;
END$$
DELIMITER ;

CALL insert_test();

-- 测试结果：
写入QPS：2,856 TPS           # 单机写入不到3000 TPS
平均响应时间：350ms
P99响应时间：1,200ms
磁盘IO：90%                  # ❌ 磁盘IO已经是瓶颈
CPU使用率：35%

问题分析：

如果10万请求全部写MySQL：
10万QPS ÷ 3000QPS/台 = 34台MySQL主库！

即使分库分表（8个库）：
10万QPS ÷ 8库 = 12,500 QPS/库
12,500 QPS ÷ 3000QPS/台 = 需要每个库4台主库

总共需要：8库 * 4主 = 32台MySQL主库！
成本爆炸！

为什么MySQL成为瓶颈？

  1. ❌ 磁盘IO慢： 即使SSD，顺序写入性能也只有3-5万IOPS
  2. ❌ 事务开销： 每次写入都需要redo log、binlog
  3. ❌ 锁竞争： 高并发写入导致锁等待
  4. ❌ 主从延迟： 主从复制延迟影响一致性
E. RocketMQ层（性能充足）

单机性能测试：

# 测试环境：8核16G
# RocketMQ官方benchmark

# 生产者测试
sh mqadmin sendMessage \
  -n 127.0.0.1:9876 \
  -t seckill-order-topic \
  -n 1000000 \
  -s 1024

# 测试结果：
生产TPS：105,372 TPS         # 单机10万TPS
平均响应时间：9.5ms
P99响应时间：28ms

# 消费者测试
消费TPS：98,567 TPS          # 单机接近10万TPS

结论：

单台RocketMQ即可支撑10万TPS！
配置3台是为了：
1. 高可用（主从切换）
2. 负载均衡（多个Broker分担压力）

9.1.4 真实压力分布（多层拦截）

实际到达各层的请求量：

graph TD A[10万用户请求] -->|100%| B[Nginx限流] B -->|50%被限流<br/>5万通过| C[应用服务器] C -->|40%重复抢购<br/>3万通过| D[Redis扣减库存] D -->|99%库存不足<br/>300成功| E[发送MQ消息] E -->|100%| F[RocketMQ队列] F -->|削峰<br/>平稳消费| G[订单服务+库存服务] G -->|300条| H[MySQL写入] B -.拦截5万.-> I[返回"请求过于频繁"] C -.拦截2万.-> J[返回"您已抢购过"] D -.拦截2.97万.-> K[返回"商品已售罄"] style B fill:#fff4e1 style C fill:#e1f5ff style D fill:#e1ffe1 style H fill:#ffe1e1

压力分布表：

环节 请求量 拦截量 通过率 压力评估
用户发起 10万 0 100% -
Nginx限流 10万 5万（限流） 50% ⚠️ 承压
应用服务器 5万 2万（重复） 60% ⚠️ 承压
Redis扣减 3万 2.97万（无库存） 1% ✅ 轻松
MQ消息 300 0 100% ✅ 轻松
MySQL写入 300 0 100% ✅ 轻松

关键结论：

✅ 秒杀系统的核心设计思想就是：多层拦截，漏斗模型

10万请求 → 5万（Nginx）→ 3万（应用）→ 300（Redis）→ 300（MySQL）

最终只有300个请求写入MySQL，远低于MySQL的承载能力（3000 QPS）

这就是为什么秒杀系统不会被打垮！

9.1.5 极端场景分析

场景1：Nginx限流失效，10万请求全部打到应用层

应用服务器承受：10万QPS
单机能力：8000 QPS
需要机器：10万 ÷ 8000 = 13台

当前配置：20台
结论：✅ 能承受（有50%余量）

场景2：Nginx + 应用层都失效，10万请求打到Redis

Redis承受：10万QPS
Redis Cluster能力：单主节点10万QPS

当前配置：3主节点
结论：✅ 能承受（性能过剩）

场景3：Redis失效，10万请求打到MySQL

MySQL承受：10万QPS写入
MySQL能力：3000 QPS/台

需要机器：10万 ÷ 3000 = 34台
当前配置：8台（分库分表）

结论：❌ 无法承受！系统崩溃！

补救措施：
1. Sentinel熔断（检测到MySQL压力过大，直接返回"系统繁忙"）
2. 降级开关（关闭秒杀，保护数据库）
3. 限流（将请求量降到MySQL能承受的范围）

9.1.6 成本优化建议

当前方案成本：

应用服务器：20台 * ¥500/月 = ¥10,000
Nginx：5台 * ¥500/月 = ¥2,500
Redis：6台 * ¥1,000/月 = ¥6,000
RocketMQ：3台 * ¥800/月 = ¥2,400
MySQL：8台 * ¥2,000/月 = ¥16,000

总计：¥36,900/月

优化方案：

方案1：使用Nginx OpenResty（推荐）

优势：在Nginx层用Lua直接操作Redis扣减库存
省去应用服务器的调用，性能提升3-5倍

优化后：
Nginx：5台（保持不变）
应用服务器：20台 → 5台（降为订单处理服务）
节省：15台 * ¥500 = ¥7,500/月

年节省：¥90,000

方案2：使用本地内存库存（激进）

优势：应用服务器本地内存分配库存，无需访问Redis

优化后：
应用服务器：20台 → 10台
Redis：6台 → 2台（只用于缓存）
节省：10台应用 + 4台Redis = ¥9,000/月

年节省：¥108,000

风险：库存分配不均、机器宕机损失库存

方案3：使用云服务Serverless（弹性伸缩）

优势：按实际使用量付费，秒杀结束后自动缩容

平时（非秒杀时段）：
应用服务器：2台
成本：¥1,000/月

秒杀时段（每天2小时）：
应用服务器：20台
成本：20台 * ¥0.5/小时 * 2小时 * 30天 = ¥600/月

总成本：¥1,600/月（省95%！）

但需要：
- 使用阿里云ECS弹性伸缩
- 使用K8s HPA自动扩容

9.1.7 压测验证（必做）

压测步骤：

# 1. 预热数据
# 将10万库存写入Redis
redis-cli SET "seckill:stock:1001" 100000

# 2. 使用JMeter压测
Thread Group:
  - Number of Threads: 100,000    # 10万并发用户
  - Ramp-Up Period: 10s           # 10秒内启动
  - Loop Count: 1                 # 每人请求1次

HTTP Request:
  - Server: seckill.example.com
  - Port: 80
  - Path: /api/seckill/buy
  - Method: POST
  - Body: {"userId": ${__Random(1,1000000)}, "goodsId": 1001}

# 3. 监控指标
- QPS（每秒请求数）
- 响应时间（P50/P90/P99）
- 错误率
- CPU/内存/网络使用率
- Redis命中率
- MySQL慢查询

# 4. 预期结果
✅ P99响应时间 < 200ms
✅ 错误率 < 1%
✅ 库存扣减准确（无超卖）
✅ 应用服务器CPU < 80%
✅ Redis响应时间 < 10ms
✅ MySQL无慢查询

9.1.8 结论与建议

评估结论：

问题 结论
10万请求能否撑住？ ✅ 能！但需要多层拦截
最大瓶颈在哪？ MySQL数据库（但实际到达的请求很少）
方案是否合理？ ✅ 合理！采用了漏斗模型
有无优化空间？ ✅ 有！使用Nginx OpenResty可省50%成本
需要压测吗？ ✅ 必须！上线前全链路压测

核心设计思想：

秒杀系统 ≠ 让所有请求都到达后端
秒杀系统 = 多层拦截 + 快速失败 + 保护核心

┌─────────────────────────────────────┐
│  前端防刷（90%用户被拦截）           │
├─────────────────────────────────────┤
│  Nginx限流（50%请求被拦截）          │
├─────────────────────────────────────┤
│  应用层检查（40%重复请求被拦截）     │
├─────────────────────────────────────┤
│  Redis扣减（99%请求无库存）          │
├─────────────────────────────────────┤
│  MQ削峰（平稳消费，保护MySQL）       │
├─────────────────────────────────────┤
│  MySQL写入（只有成功的300个订单）    │
└─────────────────────────────────────┘

最终到达MySQL的请求：300个（远小于3000 QPS的上限）

建议：

  1. ✅ 必须做全链路压测（模拟真实场景）
  2. ✅ 必须配置监控告警（实时发现问题）
  3. ✅ 必须有降级预案（Redis宕机、MySQL宕机）
  4. ✅ 建议使用Nginx OpenResty（性能提升3-5倍）
  5. ✅ 建议使用云服务弹性伸缩（成本优化95%）

十、压测与容量规划

10.1 完整压测方案

# JMeter压测脚本
# 模拟10万并发用户抢购100件商品

# 1. 创建线程组
Thread Group:
  - Number of Threads: 100000
  - Ramp-Up Period: 10s  (10秒内启动10万线程)
  - Loop Count: 1

# 2. HTTP请求配置
HTTP Request:
  - Server Name: seckill.example.com
  - Path: /api/seckill/buy
  - Method: POST
  - Body Data: 
    {
      "goodsId": 1001,
      "userId": ${__Random(1,1000000)},
      "token": "${__UUID()}"
    }

# 3. 断言
Response Assertion:
  - Response Code: 200

# 4. 聚合报告
Aggregate Report:
  - Samples: 请求总数
  - Average: 平均响应时间
  - Min/Max: 最小/最大响应时间
  - Error %: 错误率
  - Throughput: 吞吐量(QPS)

9.2 容量规划

目标： 10万QPS，100件商品

服务器配置

组件 配置 数量 说明
应用服务器 8核16G 20台 单机5000 QPS
Nginx网关 8核16G 5台 单机2万QPS
Redis Cluster 8核32G 6台（3主3从） 单节点10万QPS
RocketMQ 8核16G 3台（1主2从） 消息削峰
MySQL 16核64G 8台（4主4从） 分库分表

成本估算（阿里云为例）

应用服务器：20台 * ¥500/月 = ¥10,000/月
Nginx网关：5台 * ¥500/月 = ¥2,500/月
Redis：6台 * ¥1,000/月 = ¥6,000/月
RocketMQ：3台 * ¥800/月 = ¥2,400/月
MySQL：8台 * ¥2,000/月 = ¥16,000/月
CDN + 带宽：¥10,000/月

总计：¥46,900/月

十一、总结与最佳实践

11.1 架构设计总结

mindmap root((10万并发秒杀系统)) 前端优化 页面静态化 CDN加速 按钮防重复点击 接入层优化 Nginx限流 本地缓存 OpenResty + Lua 应用层优化 Redis预热 Lua脚本扣减 幂等性保证 限流降级 消息队列 削峰填谷 异步订单 重试机制 数据层优化 分库分表 读写分离 索引优化 高可用保障 多机房部署 熔断降级 监控告警

11.2 核心技术决策

技术点 方案选择 理由
库存扣减 Redis + Lua脚本 性能最高，原子性保证
防止超卖 Lua脚本 + 数据库兜底 Redis快速扣减，DB最终一致性
流量削峰 RocketMQ 解耦、异步、削峰
限流 Nginx + Sentinel 多层限流，保护后端
缓存 多级缓存（CDN+Nginx+Redis+本地） 减少后端压力
数据库 MySQL分库分表 应对海量订单数据
降级 开关配置 紧急情况快速止损

11.3 最佳实践清单

设计阶段

开发阶段

测试阶段

上线阶段

上线后

11.4 常见问题FAQ

Q1: Redis宕机了怎么办？
A: 使用Redis Cluster（3主3从），自动故障转移。极端情况下触发降级，直接返回"系统繁忙"。

Q2: 如何保证绝对不超卖？
A: Redis Lua脚本保证原子性 + 数据库乐观锁兜底。

Q3: 如何防止黄牛刷单？
A: 前端验证码 + 后端限流 + 风控规则（同一IP/设备/账号限制）。

Q4: 库存100件，10万人抢，如何提高用户体验？
A: 使用队列机制，前10万名进入排队，其他直接返回"已售罄"。

Q5: 如何快速扩容？
A: 使用K8s自动扩容，提前准备机器池，触发阈值自动拉起新实例。

附录

A. 数据库完整SQL

-- 创建数据库
CREATE DATABASE seckill_db DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

USE seckill_db;

-- 秒杀商品表
CREATE TABLE seckill_goods (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    goods_name VARCHAR(200) NOT NULL COMMENT '商品名称',
    goods_image VARCHAR(500) COMMENT '商品图片',
    goods_desc TEXT COMMENT '商品描述',
    original_price DECIMAL(10,2) NOT NULL COMMENT '原价',
    seckill_price DECIMAL(10,2) NOT NULL COMMENT '秒杀价',
    stock INT NOT NULL DEFAULT 0 COMMENT '库存',
    sold_count INT NOT NULL DEFAULT 0 COMMENT '已售数量',
    start_time DATETIME NOT NULL COMMENT '开始时间',
    end_time DATETIME NOT NULL COMMENT '结束时间',
    status TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0待开始 1进行中 2已结束',
    version INT NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_start_time (start_time),
    INDEX idx_status (status)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀商品表';

-- 秒杀订单表
CREATE TABLE seckill_order (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_id VARCHAR(64) NOT NULL COMMENT '订单号',
    user_id BIGINT NOT NULL COMMENT '用户ID',
    goods_id BIGINT NOT NULL COMMENT '商品ID',
    goods_name VARCHAR(200) NOT NULL COMMENT '商品名称',
    goods_price DECIMAL(10,2) NOT NULL COMMENT '商品价格',
    quantity INT NOT NULL DEFAULT 1 COMMENT '数量',
    total_amount DECIMAL(10,2) NOT NULL COMMENT '总金额',
    status TINYINT NOT NULL DEFAULT 0 COMMENT '状态：0未支付 1已支付 2已取消 3已完成 4失败',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    pay_time DATETIME COMMENT '支付时间',
    cancel_time DATETIME COMMENT '取消时间',
    UNIQUE KEY uk_order_id (order_id),
    INDEX idx_user_id (user_id),
    INDEX idx_goods_id (goods_id),
    INDEX idx_status (status),
    INDEX idx_create_time (create_time)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='秒杀订单表';

-- 插入测试数据
INSERT INTO seckill_goods (goods_name, goods_image, original_price, seckill_price, stock, start_time, end_time, status) 
VALUES 
('iPhone 15 Pro 256GB', 'https://cdn.example.com/iphone15pro.jpg', 7999.00, 5999.00, 100, '2026-01-20 20:00:00', '2026-01-20 21:00:00', 0),
('MacBook Pro 14寸', 'https://cdn.example.com/macbook.jpg', 15999.00, 12999.00, 50, '2026-01-20 20:00:00', '2026-01-20 21:00:00', 0);

B. 完整依赖清单

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Redisson（分布式锁） -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.17.7</version>
    </dependency>
    
    <!-- RocketMQ -->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>2.2.2</version>
    </dependency>
    
    <!-- MyBatis Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3</version>
    </dependency>
    
    <!-- MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    <!-- HikariCP -->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
    </dependency>
    
    <!-- Sentinel（限流降级） -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
    
    <!-- ShardingSphere（分库分表） -->
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
        <version>5.2.1</version>
    </dependency>
    
    <!-- Prometheus监控 -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
    
    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

文档版本： v1.0
最后更新： 2026-01-16
维护团队： 架构团队
适用场景： 10万并发秒杀系统、高并发电商系统、抢购系统

参考资料

posted @ 2026-01-16 14:50  菜鸟~风  阅读(0)  评论(0)    收藏  举报