Redisson分布式锁核心实现解析

在分布式系统中，协调多个节点对共享资源的访问是一个常见且具有挑战性的问题。分布式锁作为一种基础同步机制，能够确保在分布式环境下，同一时刻只有一个客户端可以访问临界资源，从而避免数据竞争和不一致的问题。

Redis 作为高性能的内存数据库，凭借其单线程模型和原子性操作，成为实现分布式锁的理想选择。然而，直接基于 Redis 实现一个健壮、可靠的分布式锁并非易事，开发者需要处理锁超时、自动续约、可重入性、故障恢复等诸多复杂问题。

Redisson 作为 Redis 的 Java 客户端，不仅提供了丰富的分布式对象和服务，还内置了生产级的分布式锁实现。它封装了复杂的底层逻辑，通过精心设计的机制（如看门狗自动续期、Lua 脚本原子操作等）解决了原生 Redis 分布式锁的诸多痛点，让开发者能够以简洁的 API 获得高可靠的分布式锁功能。

本文将深入剖析 Redisson 分布式锁的源码实现， #技术分享 #掘金从加锁、续约到解锁的全流程，揭示其背后的设计思想与关键技术点，帮助开发者更好地理解和使用这一强大的工具。

2.1 方法签名与基础逻辑

Redisson 的 tryLock 方法通过支持可配置的等待时间(waitTime)和租约时间(leaseTime)，结合线程 ID 实现可重入性识别。

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit)
    throws InterruptedException {
    
    long time = unit.toMillis(waitTime);
    long current = System.currentTimeMillis();
    long threadId = Thread.currentThread().getId();
    
    
    Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
    if (ttl == null) {
        return true;
    }
    ...
}

2.2 锁订阅与等待机制

锁订阅与等待机制：通过 Redis 的 pub/sub 监听锁释放事件避免轮询消耗，结合 Semaphore 实现线程精准挂起/唤醒。

CompletableFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);


subscribeFuture.get(time, TimeUnit.MILLISECONDS); 

do { ttl = tryAcquire(waitTime, leaseTime, unit, threadId); if (ttl == null) return true; if (ttl >= 0L && ttl < time) { lockEntry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } else { lockEntry.getLatch().tryAcquire(time, TimeUnit.MILLISECONDS); } } while(time > 0L);

信号量控制实现 ：在 Redisson 的分布式锁等待机制中，通过 RedissonLockEntry 内部的 Semaphore （信号量）实现线程的精准挂起与唤醒。当线程尝试获取锁失败时，会通过 entry.getLatch().tryAcquire() 挂起当前线程，此时信号量许可数为0导致线程阻塞；而当其他线程释放锁时，Redis 的 pub/sub 通知会触发 LockPubSub 回调，通过 Semaphore.release() 释放信号量，立即唤醒等待队列中的线程重新尝试获取锁。这种设计既避免了轮询带来的 CPU 浪费，又能实现毫秒级精度的线程调度，是 Redisson 高性能锁等待的核心实现之一。

public class RedissonLockEntry {
    private final Semaphore latch = new Semaphore(0);
    
}

2.3 原子化锁获取

方法调用链解析：

tryAcquire() → tryAcquireAsync0() → tryAcquireAsync() → tryLockInnerAsync()
                                      ↘ tryAcquireOnceAsync() → tryLockInnerAsync()

Lua 脚本解析：通过单次 Redis 调用实现了「检查锁状态→记录重入次数→刷新过期时间」的完整流程。 其优势在于：1）利用 Redis 单线程特性保证原子性，避免并发问题；2）通过 hexists 和 hincrby 支持可重入锁；3）仅当线程持有锁时才续期，避免无效操作；

if ((redis.call('exists', KEYS[1]) == 0) or
    (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]);

2.4 看门狗机制

调用顺序：

scheduleExpirationRenewal() → renewExpiration() → [ TimerTask → renewExpirationAsync → 递归 ]

初始化任务

当线程首次获取锁时会创建续期任务并立即执行，后续同一线程重入时只需记录线程 ID，通过 ConcurrentHashMap 确保每把锁只有一个续期任务，同时在 finally 块中处理线程中断情况防止资源泄漏，完整支持了锁的可重入特性和安全续期机制。

protected void scheduleExpirationRenewal(long threadId) {
    
    ExpirationEntry entry = new ExpirationEntry();
    
    
    
    ExpirationEntry oldEntry = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(
        this.getEntryName(),
        entry
    );
    if (oldEntry != null) {
        
        oldEntry.addThreadId(threadId);
    } else {
        
        entry.addThreadId(threadId);
        
        try {
            
            this.renewExpiration();
        } finally {
            
            if (Thread.currentThread().isInterrupted()) {
                this.cancelExpirationRenewal(threadId);
            }
        }
    }
}

实现自动续期

整体结构

private void renewExpiration() {
    
    ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    
    if (ee != null) {
        
        Timeout task = newTimeout(timerTask, internalLockLeaseTime/3, TimeUnit.MILLISECONDS);
        ee.setTimeout(task);
    }
}

定时任务创建 ：通过 getServiceManager().newTimeout() 创建定时续期任务，底层采用 HashedWheelTimer 时间轮算法 实现高效调度：由单个后台线程统一检测并触发到期任务，既避免了为每个锁创建独立线程的资源消耗。

Timeout task = getServiceManager().newTimeout(
    new TimerTask() {
        @Override
        public void run(Timeout timeout) {
            
        }
    },
    internalLockLeaseTime / 3L,
    TimeUnit.MILLISECONDS
);

异步续期流程 ：通过 递归调用+事件回调 实现，当看门狗触发续期时，首先异步向 Redis 发送续期请求而不阻塞线程，待收到响应后通过
CompletableFuture.whenComplete() 回调处理结果——若续期成功则重新发起延时任务（形成递归调用链），失败则立即终止任务。

优势：每次续期成功后，才会安排下一次续期（不会盲目重复），而且整个过程都是异步处理（不卡线程）。这样既省资源（不浪费 CPU），又能支持大量锁同时续期，效率很高。

CompletionStage<Boolean> future = renewExpirationAsync(threadId);
future.whenComplete((res, e) -> {
    if (e != null) {
        
        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
    } else {
        if (res) {
            renewExpiration();
        } else {  
            cancelExpirationRenewal(null);
        }
    }
});