Redis最佳实践——秒杀系统设计详解

news2025/6/3 8:39:54

在这里插入图片描述

基于Redis的高并发秒杀系统设计（十万级QPS）

一、秒杀系统核心挑战

瞬时流量洪峰：100万+ QPS请求冲击
库存超卖风险：精准扣减防止超卖
系统高可用性：99.99%服务可用性要求
数据强一致性：库存/订单/支付状态同步
用户体验保障：排队机制防止系统雪崩

二、系统架构设计（百万级并发）

核心组件说明：

CDN：缓存静态页面（商品图片/描述）
Nginx：四层负载均衡，百万级连接处理
API网关：路由分发、协议转换
Redis Cluster：库存缓存、分布式锁、计数器
Kafka：订单异步处理削峰填谷

三、库存管理核心实现

1. 库存预扣原子操作

// Lua脚本保证原子性
String script = 
    "local stock = tonumber(redis.call('get', KEYS[1]))\n" +
    "if stock > 0 then\n" +
    "    redis.call('decr', KEYS[1])\n" +
    "    return 1\n" +
    "else\n" +
    "    return 0\n" +
    "end";

Long result = jedis.eval(
    script, 
    Collections.singletonList("seckill:stock:1001"), 
    Collections.emptyList()
);

2. 库存预热方案

@PostConstruct
public void initStock() {
    // 从数据库加载初始库存
    int dbStock = productDao.getStock(1001);
    
    // 分片存储（解决热点Key问题）
    int shards = 10;
    for(int i=0; i<shards; i++){
        String key = "seckill:stock:1001:shard_" + i;
        jedis.set(key, String.valueOf(dbStock / shards));
    }
    
    // 设置总库存校验Key
    jedis.set("seckill:stock:1001:total", String.valueOf(dbStock));
}

3. 库存扣减流程

四、分布式锁精准控制

1. 防重复请求锁

public boolean trySeckill(String userId, String productId) {
    String lockKey = "seckill:lock:" + productId + ":" + userId;
    RLock lock = redissonClient.getLock(lockKey);
    
    try {
        // 尝试加锁，等待50ms，锁有效期3秒
        if (lock.tryLock(50, 3000, TimeUnit.MILLISECONDS)) {
            // 执行核心业务逻辑
            return doSeckill(userId, productId);
        }
        return false;
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

2. 库存分段锁优化

// 根据用户ID尾号分片
int shard = userId.hashCode() % 10;
String lockKey = "seckill:shard_lock:" + productId + ":" + shard;

// 使用Redisson MultiLock实现联锁
RLock shardLock = redissonClient.getLock(lockKey);
RLock globalLock = redissonClient.getLock("seckill:global_lock:" + productId);

RedissonMultiLock multiLock = new RedissonMultiLock(shardLock, globalLock);
multiLock.lock();
try {
    // 处理分片内请求
} finally {
    multiLock.unlock();
}

五、流量削峰策略

1. 令牌桶限流算法

// Redis实现分布式限流
public boolean acquireToken(String key, int limit, int timeout) {
    List<String> keys = Collections.singletonList(key);
    List<String> args = Arrays.asList(
        String.valueOf(limit), 
        String.valueOf(timeout)
    );
    
    String script = 
        "local current = redis.call('get', KEYS[1])\n" +
        "if current and tonumber(current) > tonumber(ARGV[1]) then\n" +
        "    return 0\n" +
        "else\n" +
        "    redis.call('incr', KEYS[1])\n" +
        "    redis.call('expire', KEYS[1], ARGV[2])\n" +
        "    return 1\n" +
        "end";
    
    Long result = jedis.eval(script, keys, args);
    return result == 1;
}

2. 请求排队机制

// Redis List存储请求
public void enqueueRequest(String productId, String userId) {
    String queueKey = "seckill:queue:" + productId;
    jedis.lpush(queueKey, userId);
    
    // 设置队列最大长度
    jedis.ltrim(queueKey, 0, 100000);
}

// 批量处理队列
@Scheduled(fixedDelay = 100)
public void processQueue() {
    String userId = jedis.rpop("seckill:queue:1001");
    if(userId != null) {
        handleSeckillRequest(userId);
    }
}

六、数据一致性保障

1. 最终一致性实现

2. 对账补偿机制

@Scheduled(cron = "0 0/5 * * * ?")
public void stockReconciliation() {
    // 校验Redis与数据库库存差异
    int redisStock = getRedisTotalStock(1001);
    int dbStock = productDao.getStock(1001);
    
    if(redisStock != dbStock) {
        log.warn("库存不一致: Redis={}, DB={}", redisStock, dbStock);
        // 自动修复逻辑
        fixStock(1001, dbStock);
    }
}