Redisson分布式锁原理深入分析

// 1. 获取Redisson客户端（项目里一般是配置好的，直接注入）
RedissonClient redissonClient = Redisson.create();
// 2. 获取一把分布式锁（锁的名字自己定义，比如“order:lock:123”，唯一就行）
RLock lock = redissonClient.getLock("order:lock:123");
try {
    // 3. 加锁：默认30秒过期，也能自己设置，比如lock.lock(60, TimeUnit.SECONDS)
    lock.lock();
    // 4. 执行业务逻辑（比如修改订单状态、扣减库存，这部分是咱们自己的代码）
    doBusiness();
} finally {
    // 5. 解锁：必须放在finally里，防止业务报错，锁没释放
    lock.unlock();
}

// 核心加锁方法：尝试获取锁，leaseTime是过期时间，unit是时间单位
private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, long threadId) {
    // 1. 如果设置了过期时间，直接调用tryLockInnerAsync（真正执行加锁的方法）
    if (leaseTime != -1) {
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    // 2. 如果没设置过期时间（用默认30秒），先尝试加锁
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    // 3. 加锁成功后，启动“看门狗”（续期用的），后面会讲
    ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
        if (e == null) {
            if (ttlRemaining == null) {
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}

// 真正执行加锁的方法：调用Lua脚本，和咱们之前讲的Lua逻辑一致
private <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisCommand<T> command) {
    // 转换过期时间为毫秒
    long ttl = unit.toMillis(leaseTime);
    // 返回Lua脚本的执行结果，这里就是调用Redis执行Lua脚本
    return evalWriteAsync(getName(), LongCodec.INSTANCE, command,
            "if (redis.call('exists', KEYS[1]) == 0) then " +
                "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                "return nil; " +
            "end; " +
            "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                "return nil; " +
            "end; " +
            "return redis.call('pttl', KEYS[1]);",
            Collections.singletonList(getName()), ttl, getLockName(threadId));
}

// 启动看门狗，续期用的
private void scheduleExpirationRenewal(long threadId) {
    ExpirationEntry entry = new ExpirationEntry();
    // 把当前线程的续期信息，存到本地缓存里
    EXPIRATION_RENEWAL_MAP.put(getEntryName(), entry);
    // 启动一个定时任务，每隔10秒执行一次，刷新锁的过期时间
    entry.task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            // 调用续期的Lua脚本，把锁的过期时间刷新回30秒
            RFuture<Boolean> future = renewExpirationAsync(threadId);
            future.onComplete((res, e) -> {
                if (e != null) {
                    // 续期失败，移除本地缓存，停止续期
                    EXPIRATION_RENEWAL_MAP.remove(getEntryName());
                    return;
                }
                if (res) {
                    // 续期成功，继续启动下一个定时任务，循环续期
                    scheduleExpirationRenewal(threadId);
                } else {
                    // 续期失败，移除本地缓存
                    cancelExpirationRenewal(threadId);
                }
            });
        }
    }, getLockWatchdogTimeout() / 3, TimeUnit.MILLISECONDS);
}

// 续期的核心方法：调用Lua脚本，刷新过期时间
private RFuture<Boolean> renewExpirationAsync(long threadId) {
    return evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                "return 1; " +
            "end; " +
            "return 0;",
            Collections.singletonList(getName()), getLockWatchdogTimeout(), getLockName(threadId));
}

// 核心解锁方法
public RFuture<Void> unlockAsync(long threadId) {
    // 调用解锁的Lua脚本，返回解锁结果
    RFuture<Boolean> future = unlockInnerAsync(threadId);
    future.onComplete((opStatus, e) -> {
        // 解锁成功后，停止看门狗续期
        cancelExpirationRenewal(threadId);
        if (e != null) {
            throw new CompletionException(e);
        }
        // 如果返回null，说明解锁失败（不是锁的持有者）
        if (opStatus == null) {
            throw new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                    + getNodeId() + " thread-id: " + threadId);
        }
    });
    return future;
}

// 真正执行解锁的方法：调用Lua脚本
private RFuture<Boolean> unlockInnerAsync(long threadId) {
    return evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            "if (redis.call('hexists', KEYS[1], ARGV[2]) == 0) then " +
                "return nil; " +  // 不是锁的持有者，返回null，解锁失败
            "end; " +
            "local counter = redis.call('hincrby', KEYS[1], ARGV[2], -1); " +  // 重入计数减1
            "if (counter > 0) then " +
                "redis.call('pexpire', KEYS[1], ARGV[1]); " +  // 计数还大于0，刷新过期时间
                "return 1; " +  // 解锁成功（只是计数减1，没删除锁）
            "else " +
                "redis.call('del', KEYS[1]); " +  // 计数为0，删除锁
                "return 1; " +  // 解锁成功（删除锁）
            "end;",
            Collections.singletonList(getName()), getLockWatchdogTimeout(), getLockName(threadId));
}