第22集秒杀场景下的业务梳理Redis分布式锁的优化

// 获取锁
String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
if ("OK".equals(result)) {
    // 获取锁成功
    try {
        // 执行业务逻辑
    } finally {
        // 释放锁
        jedis.del(lockKey);
    }
}

public class RedisLockWithRenewal {
    private Jedis jedis;
    private String lockKey;
    private String requestId;
    private long expireTime;
    private volatile boolean isRenewal = true;
    private ScheduledExecutorService scheduler;
    
    // 构造方法、获取锁等方法省略...
    
    // 自动续期方法
    private void startRenewal() {
        scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(() -> {
            if (isRenewal) {
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('pexpire', KEYS[1], ARGV[2]) else return 0 end";
                jedis.eval(script, Collections.singletonList(lockKey), 
                          Arrays.asList(requestId, String.valueOf(expireTime / 2)));
            }
        }, expireTime / 3, expireTime / 3, TimeUnit.MILLISECONDS);
    }
    
    // 释放锁方法
    public void releaseLock() {
        isRenewal = false;
        scheduler.shutdown();
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
    }
}

// 安全释放锁的Lua脚本
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
if (Long.valueOf(1).equals(result)) {
    // 锁释放成功
}

// 秒杀接口示例
@RequestMapping("/seckill")
public Result seckill(@RequestParam("productId") String productId) {
    // 1. 预检查（如用户是否已购买过）
    if (checkIfUserBought(productId)) {
        return Result.fail("您已参与过秒杀");
    }
    
    // 2. 获取分布式锁
    String lockKey = "seckill:lock:" + productId;
    String requestId = UUID.randomUUID().toString();
    boolean locked = redisLock.tryLock(lockKey, requestId, 30000);
    
    if (!locked) {
        return Result.fail("服务器繁忙，请稍后再试");
    }
    
    try {
        // 3. 再次检查库存（防止锁过期导致的问题）
        if (getStockFromRedis(productId) <= 0) {
            return Result.fail("商品已售罄");
        }
        
        // 4. 扣减Redis中的库存
        decreaseStockInRedis(productId);
        
        // 5. 将秒杀请求放入消息队列，异步处理订单创建等后续操作
        messageQueue.send("seckill_order_queue", new SeckillMessage(userId, productId));
        
        return Result.success("秒杀成功，请等待订单确认");
    } finally {
        // 6. 释放分布式锁
        redisLock.releaseLock(lockKey, requestId);
    }
}

// 异步处理订单创建时的库存校验
@Transactional
public void createOrder(SeckillMessage message) {
    String userId = message.getUserId();
    String productId = message.getProductId();
    
    // 再次检查数据库中的库存
    Product product = productMapper.selectById(productId);
    if (product == null || product.getStock() <= 0) {
        // 记录超卖日志，进行补偿处理
        log.warn("库存不足，秒杀失败: userId={}, productId={}", userId, productId);
        return;
    }
    
    // 检查用户是否已购买
    if (orderMapper.countByUserIdAndProductId(userId, productId) > 0) {
        log.warn("用户重复购买: userId={}, productId={}", userId, productId);
        return;
    }
    
    // 更新数据库库存
    productMapper.decreaseStock(productId);
    
    // 创建订单
    Order order = new Order();
    // 设置订单信息...
    orderMapper.insert(order);
}

// 优化前的秒杀代码
@RequestMapping("/seckill/bad")
public String badSeckill(String productId) {
    // 1. 直接访问数据库检查库存
    Product product = productMapper.selectById(productId);
    if (product == null || product.getStock() <= 0) {
        return "fail"; // 库存不足
    }
    
    // 2. 扣减库存
    product.setStock(product.getStock() - 1);
    productMapper.updateById(product);
    
    // 3. 创建订单
    Order order = new Order();
    // 设置订单信息...
    orderMapper.insert(order);
    
    return "success";
}

// 优化后的秒杀代码
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private RedissonClient redissonClient;
@Autowired
private RabbitTemplate rabbitTemplate;

@RequestMapping("/seckill/good")
public ResponseEntity goodSeckill(String productId, String userId) {
    // 1. 预检查 - 用户是否已购买（Redis缓存）
    String userKey = "seckill:user:" + userId + ":" + productId;
    Boolean hasBought = redisTemplate.hasKey(userKey);
    if (Boolean.TRUE.equals(hasBought)) {
        return ResponseEntity.badRequest().body("您已参与过秒杀");
    }
    
    // 2. 获取分布式锁
    String lockKey = "seckill:lock:" + productId;
    RLock lock = redissonClient.getLock(lockKey);
    try {
        // 尝试获取锁，最多等待1秒，锁自动过期时间30秒
        boolean locked = lock.tryLock(1, 30, TimeUnit.SECONDS);
        if (!locked) {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("服务器繁忙，请稍后再试");
        }
        
        // 3. 再次检查库存（双重检查）
        String stockKey = "seckill:stock:" + productId;
        Integer stock = (Integer) redisTemplate.opsForValue().get(stockKey);
        if (stock == null || stock <= 0) {
            return ResponseEntity.ok("商品已售罄");
        }
        
        // 4. 扣减Redis库存（原子操作）
        redisTemplate.opsForValue().decrement(stockKey);
        
        // 5. 记录用户已购买
        redisTemplate.opsForValue().set(userKey, "1", 24, TimeUnit.HOURS);
        
        // 6. 发送消息到队列，异步处理订单
        SeckillMessage message = new SeckillMessage(userId, productId);
        rabbitTemplate.convertAndSend("seckill.exchange", "seckill.key", message);
        
        return ResponseEntity.ok("秒杀成功，请等待订单确认");
    } catch (Exception e) {
        log.error("秒杀异常", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("系统异常，请稍后重试");
    } finally {
        // 7. 释放锁
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// 异步处理订单的消费者
@RabbitListener(queues = "seckill_queue")
public void processSeckillOrder(SeckillMessage message) {
    String userId = message.getUserId();
    String productId = message.getProductId();
    
    // 事务处理订单创建和库存扣减
    orderService.createSeckillOrder(userId, productId);
}