怎么用Java实现秒杀系统

发布时间：2021-11-16 10:11:27 作者：iii
来源：亿速云阅读：300

# 怎么用Java实现秒杀系统

## 1. 秒杀系统核心挑战与技术难点

秒杀系统是典型的高并发场景，需要解决以下核心问题：

1. **瞬时高并发流量**：活动开始瞬间可能产生数十万级QPS
2. **超卖问题**：库存扣减的原子性保证
3. **恶意请求**：黄牛脚本、DDOS攻击等
4. **系统雪崩**：避免单一服务崩溃导致整个系统不可用
5. **数据一致性**：库存、订单、支付的状态同步

## 2. 系统架构设计

### 2.1 分层架构设计

┌───────────────────────────────────┐ │ 客户端层 │ │ (静态资源CDN、请求限流、人机验证) │ └───────────────┬───────────────────┘ │ ┌───────────────▼───────────────────┐ │ 接入层 │ │ (负载均衡、API网关、风控拦截) │ └───────────────┬───────────────────┘ │ ┌───────────────▼───────────────────┐ │ 服务层 │ │ (业务逻辑、分布式事务、缓存) │ └───────────────┬───────────────────┘ │ ┌───────────────▼───────────────────┐ │ 数据层 │ │ (分库分表、读写分离、MQ异步) │ └───────────────────────────────────┘


### 2.2 技术选型建议

| 组件类型       | 推荐方案                          |
|----------------|-----------------------------------|
| 开发框架       | Spring Boot + Spring Cloud        |
| 缓存           | Redis Cluster + Redisson          |
| 消息队列       | RocketMQ/Kafka                    |
| 数据库         | MySQL + ShardingSphere            |
| 限流组件       | Sentinel/Guava RateLimiter        |
| 分布式锁       | Redis Lua脚本/Zookeeper           |
| 监控系统       | Prometheus + Grafana              |

## 3. 核心代码实现

### 3.1 库存预热与缓存

```java
@Service
public class InventoryService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 商品库存预热
    public void preheatInventory(Long itemId, int stock) {
        String key = "sec_kill:stock:" + itemId;
        redisTemplate.opsForValue().set(key, String.valueOf(stock));
        
        // 设置过期时间避免脏数据
        redisTemplate.expire(key, 24, TimeUnit.HOURS);
    }
    
    // 获取当前缓存库存
    public int getCacheStock(Long itemId) {
        String key = "sec_kill:stock:" + itemId;
        String val = redisTemplate.opsForValue().get(key);
        return val == null ? 0 : Integer.parseInt(val);
    }
}

3.2 分布式锁实现

public class RedisDistributedLock {
    private static final String LOCK_PREFIX = "sec_kill:lock:";
    private static final int DEFAULT_EXPIRE = 30; // 秒
    
    public static boolean tryLock(String lockKey, String requestId) {
        String key = LOCK_PREFIX + lockKey;
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            JedisCommands commands = (JedisCommands) connection.getNativeConnection();
            String result = commands.set(key, requestId, 
                "NX", "EX", DEFAULT_EXPIRE);
            return "OK".equals(result);
        });
    }
    
    public static boolean releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                       "return redis.call('del', KEYS[1]) " +
                       "else return 0 end";
        return redisTemplate.execute(
            (RedisCallback<Boolean>) connection -> {
                Object result = connection.eval(
                    script.getBytes(),
                    ReturnType.INTEGER,
                    1,
                    (LOCK_PREFIX + lockKey).getBytes(),
                    requestId.getBytes());
                return result.equals(1L);
            });
    }
}

3.3 秒杀核心逻辑

@RestController
public class SecKillController {
    
    @PostMapping("/seckill")
    public Result seckill(@RequestParam Long itemId, 
                         @RequestParam Integer userId) {
        // 1. 参数校验
        if (itemId == null || userId == null) {
            return Result.error("参数错误");
        }
        
        // 2. 风控校验（频率限制、黑名单等）
        if (!riskCheck(userId)) {
            return Result.error("操作频繁");
        }
        
        // 3. 内存标记（减少Redis访问）
        if (!ItemStockCache.getStatus(itemId)) {
            return Result.error("已售罄");
        }
        
        // 4. Redis预减库存
        Long stock = redisTemplate.opsForValue().decrement(
            "sec_kill:stock:" + itemId);
        if (stock == null || stock < 0) {
            // 恢复库存
            redisTemplate.opsForValue().increment(
                "sec_kill:stock:" + itemId);
            ItemStockCache.setStatus(itemId, false);
            return Result.error("已售罄");
        }
        
        // 5. 消息队列异步处理
        SecKillMessage message = new SecKillMessage(userId, itemId);
        rocketMQTemplate.send("sec_kill_queue", message);
        
        return Result.success("排队中");
    }
}

3.4 异步下单消费者

@Component
@RocketMQMessageListener(
    topic = "sec_kill_queue",
    consumerGroup = "sec_kill_group")
public class OrderConsumer implements RocketMQListener<SecKillMessage> {
    
    @Override
    public void onMessage(SecKillMessage message) {
        try {
            // 1. 数据库校验库存
            Item item = itemMapper.selectForUpdate(message.getItemId());
            if (item.getStock() <= 0) {
                return;
            }
            
            // 2. 创建订单
            Order order = createOrder(message.getUserId(), item);
            
            // 3. 扣减真实库存
            int affected = itemMapper.reduceStock(
                message.getItemId(), order.getCount());
            if (affected == 0) {
                throw new RuntimeException("库存不足");
            }
            
            // 4. 支付超时处理（定时任务）
            delayQueue.add(new PayCheckTask(order.getId()));
        } catch (Exception e) {
            // 恢复Redis库存
            redisTemplate.opsForValue().increment(
                "sec_kill:stock:" + message.getItemId());
            ItemStockCache.setStatus(message.getItemId(), true);
        }
    }
}

4. 关键优化技术

4.1 多级缓存设计

浏览器缓存：静态资源设置Cache-Control
CDN缓存：商品图片等静态内容分发
本地缓存：Caffeine实现JVM级别缓存
分布式缓存：Redis集群缓存热点数据

// 多级缓存示例
public class ItemCache {
    @Autowired
    private RedisTemplate redisTemplate;
    private Cache<Long, Item> localCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build();
    
    public Item getItem(Long id) {
        // 1. 查本地缓存
        Item item = localCache.getIfPresent(id);
        if (item != null) return item;
        
        // 2. 查Redis
        String key = "item:" + id;
        item = (Item)redisTemplate.opsForValue().get(key);
        if (item != null) {
            localCache.put(id, item);
            return item;
        }
        
        // 3. 查数据库
        item = itemMapper.selectById(id);
        if (item != null) {
            redisTemplate.opsForValue().set(key, item, 1, TimeUnit.HOURS);
            localCache.put(id, item);
        }
        return item;
    }
}

4.2 流量削峰方案

答题验证：增加算术验证码环节
队列泄洪：使用线程池控制并发处理数
请求排队：Redis List实现排队系统
分桶计数：将库存分散到多个Key

// 令牌桶限流实现
public class RateLimiterService {
    private final RateLimiter rateLimiter = RateLimiter.create(1000); // QPS=1000
    
    public boolean tryAcquire() {
        return rateLimiter.tryAcquire();
    }
}

// 分桶库存示例
public class BucketStockService {
    public boolean reduceStock(Long itemId) {
        // 将库存分为10个桶
        String bucketKey = "stock_bucket:" + itemId + ":" + 
            (ThreadLocalRandom.current().nextInt(10));
        Long remain = redisTemplate.execute(
            new DefaultRedisScript<>(STOCK_REDUCE_SCRIPT, Long.class),
            Collections.singletonList(bucketKey));
        return remain != null && remain >= 0;
    }
    
    private static final String STOCK_REDUCE_SCRIPT =
        "local current = tonumber(redis.call('get', KEYS[1])) " +
        "if current > 0 then " +
        "   redis.call('decr', KEYS[1]) " +
        "   return 1 " +
        "else " +
        "   return -1 " +
        "end";
}

4.3 防刷与安全

人机验证：集成Google reCAPTCHA
频率限制：IP/用户维度的滑动窗口计数
数据加密：敏感字段AES加密传输
链路追踪：埋点识别异常请求模式

// 滑动窗口限流
public class SlidingWindowLimiter {
    private final RedisTemplate<String, String> redisTemplate;
    
    public boolean allowRequest(String key, int windowSize, int maxCount) {
        long now = System.currentTimeMillis();
        long windowStart = now - windowSize * 1000L;
        
        // 使用Redis ZSET实现滑动窗口
        redisTemplate.opsForZSet().add(key, String.valueOf(now), now);
        redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);
        
        Long count = redisTemplate.opsForZSet().zCard(key);
        return count != null && count <= maxCount;
    }
}

5. 监控与降级方案

5.1 监控指标

系统指标：CPU、内存、线程数、GC情况
业务指标：PV/UV、下单转化率、库存变化
异常监控：慢查询、接口超时、错误日志

5.2 降级策略

读降级：直接返回缓存数据
写降级：将请求写入队列后快速返回
功能降级：关闭非核心功能（如评价、推荐）

// 熔断降级示例
@RestController
@DefaultProperties(defaultFallback = "defaultFallback")
public class SecKillController {
    
    @HystrixCommand(
        commandProperties = {
            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value="1000"),
            @HystrixProperty(name="circuitBreaker.errorThresholdPercentage",value="50")
        },
        fallbackMethod = "seckillFallback"
    )
    @PostMapping("/seckill")
    public Result seckill(...) {
        // 正常业务逻辑
    }
    
    public Result seckillFallback(...) {
        return Result.error("系统繁忙，请稍后重试");
    }
    
    public Result defaultFallback() {
        return Result.error("服务暂时不可用");
    }
}

6. 压测与优化建议

6.1 压测方案

基准测试：使用JMeter模拟不同并发量
阶梯增压：逐步增加并发观察系统表现
全链路压测：生产环境影子表压测

6.2 优化checklist

[ ] 减少Full GC次数（建议次/天）
[ ] 接口RT控制在200ms内
[ ] Redis命中率>99%
[ ] MySQL慢查询<0.1%
[ ] 错误率<0.5%

7. 总结与扩展

实现高性能秒杀系统需要综合运用多种技术：

分层过滤：逐层拦截无效请求
异步化：将串行操作改为并行
缓存优先：减少数据库直接访问
柔性可用：保证核心链路可用性

扩展方向： - 结合大数据分析用户行为 - 实现动态库存调整 - 搭建智能风控系统 - 探索Serverless架构应用

实际开发中需要根据业务特点进行调整，建议先在小流量场景验证方案可行性，再逐步全量上线。 “`

这篇文章共计约3650字，涵盖了秒杀系统的完整实现方案，从架构设计到核心代码实现，再到优化策略和监控方案。如需进一步扩展某些模块或调整技术方案，可以具体讨论补充。