Java 高并发秒杀系统设计：架构、防超卖与性能优化

方案三：预扣库存

先扣 Redis 库存，再异步同步到 DB。若 Redis 扣减失败则回滚。

public boolean preDeductStock(String productId, int count) {
    String key = "seckill:stock:" + productId;
    Long remaining = redisTemplate.opsForValue().decrement(key, count);
    if (remaining >= 0) {
        // 发送 MQ 消息异步扣减数据库
        sendStockDeductMessage(productId, count);
        return true;
    } else {
        // 库存不足，回滚
        redisTemplate.opsForValue().increment(key, count);
        return false;
    }
}

2. 高并发请求处理

2.1 流量削峰

用户请求不直接落库，而是进入消息队列，后端服务按能力消费。

@Component
public class SeckillService {
    @Autowired
    private RocketMQTemplate mqTemplate;

    public SeckillResult seckill(SeckillRequest request) {
        if (!validate(request)) {
            return SeckillResult.fail("校验失败");
        }
        String requestId = generateRequestId(request);
        // 请求入队，立即返回
        mqTemplate.sendOneWay("seckill-topic", MessageBuilder.withPayload(request).build());
        return SeckillResult.processing(requestId);
    }
}

2.2 分层过滤

请求经过多层过滤，大幅降低到达后端的压力：

所有请求 → 合法性校验 → 库存校验 → 频率控制 → 实际下单
   100 万      50 万           10 万          5 万       1 万

3. 系统性能优化

3.1 缓存策略

采用多级缓存架构：

• 一级：JVM 本地缓存 (Caffeine)，存热点商品详情。
• 二级：Redis 集群，存库存信息和布隆过滤器。
• 三级：数据库，保证最终一致性。

3.2 读多写少优化

活动开始前进行缓存预热，减少冷启动时的数据库压力。

@Service
public class CacheWarmUpService {
    @PostConstruct
    public void warmUpSeckillProducts() {
        List<Product> hotProducts = loadHotProducts();
        for (Product product : hotProducts) {
            redisTemplate.opsForValue().set(
                "stock:" + product.getId(), product.getStock()
            );
            redisTemplate.opsForValue().set(
                "product:" + product.getId(), JSON.toJSONString(product)
            );
            bloomFilter.add(product.getId());
        }
    }
}

4. 详细实现方案

4.1 秒杀流程

这里梳理一下核心的逻辑链路，确保每一步都有防护：

public Response processSeckill(String userId, String productId) {
    // 1. 恶意请求拦截
    if (!checkRisk(userId)) {
        return Response.error("访问过于频繁");
    }
    // 2. 布隆过滤器快速判断
    if (!bloomFilter.contains(productId)) {
        return Response.error("商品不存在");
    }
    // 3. 内存标记（已售罄的商品直接返回）
    if (soldOutFlags.get(productId)) {
        return Response.error("已售罄");
    }
    // 4. Redis 原子扣减库存
    if (!deductStockInRedis(productId)) {
        soldOutFlags.put(productId, true);
        return Response.error("库存不足");
    }
    // 5. 生成订单 ID（雪花算法）
    String orderId = snowflake.generate();
    // 6. 订单信息入队
    mq.send(OrderDTO.builder()
        .orderId(orderId)
        .userId(userId)
        .productId(productId)
        .build());
    // 7. 返回排队中
    return Response.success("排队中", orderId);
}

4.2 库存同步方案

异步任务负责将 Redis 中的库存变更持久化到数据库，并定期对账。

@Component
@Slf4j
public class StockSyncService {
    @Transactional
    public void syncStockToDB(String productId, int count) {
        try {
            boolean success = productDAO.deductStock(productId, count);
            if (success) {
                redisTemplate.opsForValue().set(
                    "stock_final:" + productId, getDBStock(productId)
                );
                soldOutCache.remove(productId);
            }
        } catch (Exception e) {
            log.error("库存同步失败", e);
            alertService.sendAlert(e);
        }
    }

    @Scheduled(cron = "0 */5 * * * ?")
    public void stockReconciliation() {
        List<Product> products = productDAO.getAllSeckillProducts();
        for (Product product : products) {
            Integer redisStock = getRedisStock(product.getId());
            Integer dbStock = product.getStock();
            if (!Objects.equals(redisStock, dbStock)) {
                log.warn("库存不一致：productId={}, redis={}, db={}", 
                    product.getId(), redisStock, dbStock);
                fixStockInconsistency(product.getId(), dbStock);
            }
        }
    }
}

高可用保障

1. 限流降级策略

多维度限流配置，保护核心服务不被压垮：

• 用户维度：每个用户 10 次/分钟
• IP 维度：每个 IP 1000 次/分钟
• 商品维度：每个商品 10000 次/分钟
• 总 QPS：系统最大承受 50000 QPS

2. 熔断降级

当依赖服务响应过慢时，自动触发熔断，返回友好提示。

@RestController
@Slf4j
public class SeckillController {
    @GetMapping("/seckill/{productId}")
    @HystrixCommand(fallbackMethod = "seckillFallback", 
        commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000"),
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20")
        })
    public Response seckill(@PathVariable String productId, @RequestParam String userId) {
        return seckillService.process(userId, productId);
    }

    public Response seckillFallback(String productId, String userId) {
        return Response.error("系统繁忙，请稍后重试");
    }
}

监控与告警

1. 关键监控指标

• 系统层面：QPS、RT、错误率、CPU/内存使用率
• 应用层面：库存扣减成功率、消息堆积量
• 业务层面：抢购成功率、用户排队时长

2. 监控实现

@Component
public class SeckillMonitor {
    private final MeterRegistry meterRegistry;

    public void recordSeckill(String productId, boolean success, long cost) {
        meterRegistry.counter("seckill.requests.total").increment();
        if (success) {
            meterRegistry.counter("seckill.success.total").increment();
        } else {
            meterRegistry.counter("seckill.fail.total").increment();
        }
        meterRegistry.timer("seckill.process.time")
            .record(cost, TimeUnit.MILLISECONDS);
        meterRegistry.gauge("seckill.stock." + productId, getCurrentStock(productId));
    }
}

部署与扩展

1. 弹性扩展策略

• 水平扩展：无状态服务可快速扩容
• 自动伸缩：基于 CPU 使用率或 QPS 自动扩缩容
• 异地多活：重要业务支持多机房部署

2. 压测方案

• 场景 1：库存预热，10 万用户同时抢 1 万商品
• 场景 2：持续高压，5 万 QPS 持续 5 分钟
• 场景 3：峰值冲击，瞬间 20 万 QPS
• 目标：成功率 >99.9%，平均 RT <100ms，错误率 <0.1%

安全考虑

• 防刷机制：验证码（峰值时降级）、设备指纹、行为分析
• 数据安全：关键数据加密、操作日志记录、防篡改校验

核心总结

设计秒杀系统，核心在于动静分离、分层削峰和最终一致性。

1. 架构上：静态资源推送到 CDN，网关层做限流，业务逻辑后置并队列化。用户点击抢购后，服务端返回'排队中'，请求进入消息队列平滑处理。
2. 库存上：利用 Redis 原子操作（LUA 脚本）预扣库存，彻底杜绝超卖；数据库作为兜底，通过乐观锁和对账任务保证数据最终一致。
3. 性能上：多级缓存预热，热点 Key 散列分散压力，服务无状态化便于横向扩容。
4. 稳定上：完善的熔断降级、限流隔离机制，配合全链路监控，确保系统在极端流量下依然可控。

实战中，还要特别注意防刷验证、异步下单结果轮询以及异常情况的对账修复。只有把这些细节都落实到位，才能支撑起万人级别的并发抢购。