lua
-- KEYS[1]:{gid}:stock 商品库存key
-- KEYS[2]:{gid}:user_set 已抢购用户集合
-- ARGV[1]:用户ID
-- 返回码约定：
-- 1 成功  -1 库存不足  -2 重复抢购  -99 缓存不存在(需懒加载)

-- 1、判断用户是否重复下单
if redis.call("SISMEMBER",KEYS[2],ARGV[1]) == 1 then
    return -2
end

-- 2、判断Redis缓存是否存在
local stock = redis.call("GET",KEYS[1])
if stock == nil or stock == "" then
    return -99
end

-- 3、判断库存是否充足
local num = tonumber(stock)
if num < 1 then
    return -1
end

-- 4、原子扣库存+标记用户（防超卖、防重复）
redis.call("DECRBY",KEYS[1],1)
redis.call("SADD",KEYS[2],ARGV[1])

return 1

java
@Autowired
private RedissonClient redissonClient;

@Autowired
private StringRedisTemplate redisTemplate;

@Autowired
private GoodsMapper goodsMapper;

// 秒杀内存队列
private final BlockingQueue<SeckillMsg> seckillQueue = new LinkedBlockingQueue<>(100000);

// 秒杀核心入口方法
public Result<String> seckill(long goodsId, long userId) {
    // 构造HashTag同分片Key，保证Lua集群原子执行
    String stockKey = "goods:{" + goodsId + "}:stock";
    String userSetKey = "goods:{" + goodsId + "}:user_set";
    // 商品维度分布式锁Key（单商品唯一）
    String lockKey = "lock:goods:init:" + goodsId;

    List<String> keys = Arrays.asList(stockKey, userSetKey);

    // 1.首次执行Lua脚本判断秒杀状态
    Long res = redisTemplate.execute(seckillLuaScript, keys, String.valueOf(userId));

    // 2.缓存不存在，触发懒加载+分布式锁防击穿逻辑
    if (res == -99) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 等待5秒、超时10秒自动释放，防止死锁
            boolean lockSuccess = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!lockSuccess) {
                return Result.fail("系统繁忙，请稍后再试");
            }

            // 3.Double Check：二次校验缓存是否已被初始化
            String existStock = redisTemplate.opsForValue().get(stockKey);
            if (existStock == null) {
                // 查询数据库真实库存
                Integer dbStock = goodsMapper.getStockByGoodsId(goodsId);
                // DB无库存，写入空缓存，防止持续穿透
                if (dbStock == null || dbStock <= 0) {
                    redisTemplate.opsForValue().set(stockKey, "0", 5, TimeUnit.MINUTES);
                    return Result.fail("库存不足");
                }
                // 初始化Redis缓存，完成懒加载
                redisTemplate.opsForValue().set(stockKey, String.valueOf(dbStock));
            }
        } catch (InterruptedException e) {
            return Result.fail("系统繁忙");
        } finally {
            // 仅当前线程持有锁时才释放
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }

        // 4.缓存初始化完成，重试秒杀逻辑
        res = redisTemplate.execute(seckillLuaScript, keys, String.valueOf(userId));
    }

    // 5.统一处理秒杀结果
    if (res == 1) {
        // 秒杀成功，入内存队列异步落库，立即响应前端
        seckillQueue.offer(new SeckillMsg(goodsId, userId));
        return Result.success("秒杀成功，订单处理中...");
    } else if (res == -1) {
        return Result.fail("库存不足");
    } else if (res == -2) {
        return Result.fail("您已参与过秒杀，请勿重复抢购");
    } else {
        return Result.fail("秒杀失败");
    }
}

方案

优点

缺点

适用场景

提前缓存预热

秒杀全程无DB查询，性能极致、无阻塞

运维成本高、易漏预热、占用闲置内存

固定大促、爆款商品少、场次固定

无需预热、零运维、节省内存、防击穿、高并发安全

首次请求少量逻辑开销，几乎可忽略

商品多、零散秒杀、不定期爆款活动