高可靠Redis分布式锁实现方案（含自动续期 & 看门狗机制）

业务代码
   ↓
分布式锁接口（Lock / RLock）
   ↓
RedissonClient / 自研RedisLock
   ├─ Lua脚本加锁（原子性）
   ├─ 定时任务线程池（Watchdog）
   │    ↓
   └─ 后台自动续期（EXPIRE）
        ↓
Redis Server（Hash + Key）

Key: lock_key:order:12345
Type: Hash
Fields:
  "client:thread-uuid:threadId" → "2"   （重入次数）
  "client:thread-uuid:threadId" → "5"   （示例）
Expire: 30s（初始） → 由看门狗动态续期

-- KEYS[1] = lock key
-- ARGV[1] = thread unique id (uuid:threadId)
-- ARGV[2] = internalLockLeaseTime (默认30s)
​
if redis.call('hexists', KEYS[1], ARGV[1]) == 0 then
    redis.call('hset', KEYS[1], ARGV[1], 1);
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 1;
end;
​
if redis.call('hexists', KEYS[1], ARGV[1]) == 1 then
    redis.call('hincrby', KEYS[1], ARGV[1], 1);
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 1;
end;
​
return 0;

-- KEYS[1] = lock key
-- ARGV[1] = internalLockLeaseTime (30s)
​
if redis.call('hexists', KEYS[1], ARGV[1]) == 1 then
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 1;
end;
​
return 0;

-- KEYS[1] = lock key
-- ARGV[1] = thread unique id
​
local counter = redis.call('hget', KEYS[1], ARGV[1]);
if counter == false then
    return nil;
end
​
counter = tonumber(counter);
​
if counter <= 0 then
    redis.call('del', KEYS[1]);
    return nil;
end
​
counter = counter - 1;
redis.call('hset', KEYS[1], ARGV[1], counter);
​
if counter > 0 then
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 0;
else
    redis.call('del', KEYS[1]);
    return 1;
end

// 推荐写法（启用看门狗）
RLock lock = redissonClient.getLock("lock:seckill:sku:" + skuId);
​
try {
    // 建议等待时间 500~1500ms，根据实际压测调整
    // -1 表示不限等待（但生产慎用，易堆积）
    boolean acquired = lock.tryLock(800, TimeUnit.MILLISECONDS);
    if (!acquired) {
        // 抢锁失败 → 返回“商品已抢光”或进入排队/降级逻辑
        return SeckillResult.fail(SeckillCode.OUT_OF_STOCK_OR_BUSY);
    }
​
    // 核心业务逻辑
    // 1. 读库存（lua 或 pipeline）
    // 2. 判断是否还有库存 & 用户限购
    // 3. 扣减库存（Lua原子）
    // 4. 记录抢购成功订单（异步MQ）
    Long stock = decrementStockLua(skuId, buyQuantity);
    if (stock < 0) {
        return SeckillResult.fail(SeckillCode.OUT_OF_STOCK);
    }
​
    // 异步发MQ创建订单
    orderEventProducer.sendCreateOrderEvent(userId, skuId, ...);
​
    return SeckillResult.success();
​
} catch (Exception e) {
    log.error("秒杀异常", e);
    // 可选：补偿性回滚（视幂等设计）
    return SeckillResult.fail(SeckillCode.SYSTEM_ERROR);
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

// 支付回调接口（Controller / MQ Listener）
public void onPayCallback(PayNotifyDTO dto) {
    String lockKey = "lock:pay:order:" + dto.getOrderNo();
​
    RLock lock = redissonClient.getLock(lockKey);
​
    try {
        // 支付回调等待时间可以稍长（渠道重试间隔通常较长）
        if (!lock.tryLock(3, 45, TimeUnit.SECONDS)) {
            log.warn("支付回调获取锁失败，稍后重试 orderNo:{}", dto.getOrderNo());
            // 可选择：NACK / 重新入队 / 记录延迟处理
            return;
        }
​
        // 检查是否已处理（防幂等核心）
        if (isOrderAlreadyPaid(dto.getOrderNo())) {
            log.info("订单已支付，幂等返回 orderNo:{}", dto.getOrderNo());
            return;
        }
​
        // 核心处理
        boolean success = processPayment(dto);
        if (success) {
            updateOrderStatusPaid(dto.getOrderNo(), dto.getTradeNo());
            // 发MQ通知下游（发货、积分、券等）
        }
​
    } catch (Exception e) {
        log.error("支付回调处理异常", e);
        // 可记录到死信 / 人工审核
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// 使用 Redisson 的 RLock（而非 RSemaphore / RCountDownLatch）
@Scheduled(cron = "0 0/5 * * * ?")   // 每5分钟
public void executeClearExpiredCouponTask() {
    String lockKey = "lock:task:clear_expired_coupon";
​
    RLock lock = redissonClient.getLock(lockKey);
​
    if (!lock.tryLock()) {
        log.info("定时任务-清理过期优惠券 获取锁失败，本次跳过");
        return;
    }
​
    try {
        log.info("开始清理过期优惠券...");
        couponService.clearExpiredCoupons(LocalDateTime.now().minusDays(30));
        log.info("清理过期优惠券完成");
    } catch (Exception e) {
        log.error("清理过期优惠券任务异常", e);
        // 可选：告警
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}