Redisson分布式锁分析

2019独角兽企业重金招聘Python工程师标准>>>

RedissonLock继承结构：

RLock接口中定义的方法：主要分析tryLock()实现。

---

**(一) RedissonLock#tryLock:**加锁逻辑

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    long time = unit.toMillis(waitTime);// 等待时间
    long current = System.currentTimeMillis();
    final long threadId = Thread.currentThread().getId();// 使用当前线程ID，实现重入锁
    Long ttl = tryAcquire(leaseTime, unit, threadId);// 尝试获取锁
    // lock acquired
    if (ttl == null) {// 没有过期时间，未上锁，直接返回获取成功
        return true;
    }
    time -= (System.currentTimeMillis() - current);
    if (time <= 0) {// 等待时间已超时
        acquireFailed(threadId);
        return false;
    }
    current = System.currentTimeMillis();
    // 订阅锁的队列，等待锁被其余线程释放后通知
    // 通过Redis的Channel订阅监听队列，subscribe内部通过信号量semaphore，再通过await方法阻塞，内部其实是用CountDownLatch来实现阻塞，获取subscribe异步执行的结果，来保证订阅成功
    final RFuture subscribeFuture = subscribe(threadId);
    if (!await(subscribeFuture, time, TimeUnit.MILLISECONDS)) {// 阻塞等待subscribe的future的结果对象(即分布式解锁消息的结果)
        if (!subscribeFuture.cancel(false)) {
            subscribeFuture.addListener(new FutureListener() {
                @Override
                public void operationComplete(Future future) throws Exception {
                    if (subscribeFuture.isSuccess()) {
                        unsubscribe(subscribeFuture, threadId);
                    }
                }
            });
        }
        acquireFailed(threadId);
        return false;
    }

    try {
        time -= (System.currentTimeMillis() - current);
        if (time <= 0) {// subscribe方法调用超时，取消订阅，不再继续申请锁
            acquireFailed(threadId);
            return false;
        }

        while (true) {
            long currentTime = System.currentTimeMillis();
            ttl = tryAcquire(leaseTime, unit, threadId);// 再次尝试申请锁
            if (ttl == null) {// 获得锁，返回
                return true;
            }

            time -= (System.currentTimeMillis() - currentTime);
            if (time <= 0) {// 超时
                acquireFailed(threadId);
                return false;
            }

            // waiting for message 等待订阅的队列消息
            currentTime = System.currentTimeMillis();
            // 通过信号量(共享锁)阻塞,等待解锁消息(这一点设计的非常精妙：减少了其他分布式节点的等待或者空转等无效锁申请的操作，整体提高了性能)
            if (ttl >= 0 && ttl < time) {// 在ttl内，从Entry的信号量获取一个许可(除非被中断或者一直没有可用的许可)
                getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {// 在等待剩余时间内...
                getEntry(threadId).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
            }

            time -= (System.currentTimeMillis() - currentTime);
            if (time <= 0) {// 超时
                acquireFailed(threadId);
                return false;
            }
        }
    } finally {
        unsubscribe(subscribeFuture, threadId);// 无论是否获得锁,都要取消订阅解锁消息
    }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
}
## RedissonLock#getEntry -> RedissonLock#getEntryName
protected String getEntryName() {
    return id + ":" + getName();// 客户端实例ID+锁名称来保证多个实例下的锁可重入
}

---

0x0001:**RedissonLock#tryAcquire:**尝试获取锁

private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
    return get(tryAcquireAsync(leaseTime, unit, threadId));
}
## RedissonObject#get
protected final CommandAsyncExecutor commandExecutor;
protected final  V get(RFuture future) {
    return commandExecutor.get(future);
}

---

0x0010:**RedissonLock#tryAcquireAsync:**异步尝试获取锁，异步调用，get方法阻塞

## RedissonLock#tryAcquireAsync
private  RFuture tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
    if (leaseTime != -1) {// 起租时间不为空
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    // lockWatchdogTimeout = 30 * 1000默认30秒
    RFuture ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    ttlRemainingFuture.addListener(new FutureListener() {
        @Override
        public void operationComplete(Future future) throws Exception {
            if (!future.isSuccess()) {
                return;
            }
            Long ttlRemaining = future.getNow();
            if (ttlRemaining == null) {// 拿到锁
                scheduleExpirationRenewal(threadId);
            }
        }
    });
    return ttlRemainingFuture;
}
## RedissonLock#scheduleExpirationRenewal Redisson避免死锁方案，避免锁未被释放。
## 若未设置过期时间的话，redission默认的过期时间是30s，同时未避免锁在业务未处理完成之前被提前释放，Redisson在获取到锁且默认过期时间的时候，会在当前客户端内部启动一个定时任务，每隔internalLockLeaseTime/3的时间去刷新key的过期时间，这样既避免了锁提前释放，同时如果客户端宕机的话，这个锁最多存活30s的时间就会自动释放
if (expirationRenewalMap.containsKey(getEntryName())) {
    return;
}
Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
    @Override
    public void run(Timeout timeout) throws Exception {
        RFuture future = commandExecutor.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.