private void redissonDoc() throws InterruptedException {
    //1. 普通的可重入鎖
    RLock lock = redissonClient.getLock("generalLock");
 
    // 拿鎖失敗時(shí)會(huì)不停的重試
    // 具有Watch Dog 自動(dòng)延期機(jī)制 默認(rèn)續(xù)30s 每隔30/3=10 秒續(xù)到30s
    lock.lock();
 
    // 嘗試拿鎖10s后停止重試,返回false
    // 具有Watch Dog 自動(dòng)延期機(jī)制 默認(rèn)續(xù)30s
    boolean res1 = lock.tryLock(10, TimeUnit.SECONDS);
 
    // 拿鎖失敗時(shí)會(huì)不停的重試
    // 沒(méi)有Watch Dog ，10s后自動(dòng)釋放
    lock.lock(10, TimeUnit.SECONDS);
 
    // 嘗試拿鎖100s后停止重試,返回false
    // 沒(méi)有Watch Dog ，10s后自動(dòng)釋放
    boolean res2 = lock.tryLock(100, 10, TimeUnit.SECONDS);
 
    //2. 公平鎖 保證 Redisson 客戶端線程將以其請(qǐng)求的順序獲得鎖
    RLock fairLock = redissonClient.getFairLock("fairLock");
 
    //3. 讀寫鎖 沒(méi)錯(cuò)與JDK中ReentrantLock的讀寫鎖效果一樣
    RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("readWriteLock");
    readWriteLock.readLock().lock();
    readWriteLock.writeLock().lock();
}

 // 直接使用lock無(wú)參數(shù)方法
public void lock() {
    try {
        lock(-1, null, false);
    } catch (InterruptedException e) {
        throw new IllegalStateException();
    }
}
 
// 進(jìn)入該方法 其中l(wèi)easeTime = -1
private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
    long threadId = Thread.currentThread().getId();
    Long ttl = tryAcquire(-1, leaseTime, unit, threadId);
    // lock acquired
    if (ttl == null) {
        return;
    }
 
   //...
}
 
// 進(jìn)入 tryAcquire(-1, leaseTime, unit, threadId)
private Long tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    return get(tryAcquireAsync(waitTime, leaseTime, unit, threadId));
}
 
// 進(jìn)入 tryAcquireAsync
private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    if (leaseTime != -1) {
        return tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    //當(dāng)leaseTime = -1 時(shí) 啟動(dòng) watch dog機(jī)制
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(waitTime,
                                            commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(),
                                            TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    //執(zhí)行完lua腳本后的回調(diào)
    ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
        if (e != null) {
            return;
        }
 
        if (ttlRemaining == null) {
            // watch dog 
            scheduleExpirationRenewal(threadId);
        }
    });
    return ttlRemainingFuture;
}

private void scheduleExpirationRenewal(long threadId) {
    ExpirationEntry entry = new ExpirationEntry();
    //將線程放入緩存中
    ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
    //第二次獲得鎖后 不會(huì)進(jìn)行延期操作
    if (oldEntry != null) {
        oldEntry.addThreadId(threadId);
    } else {
        entry.addThreadId(threadId);
        
        // 第一次獲得鎖 延期操作
        renewExpiration();
    }
}
 
// 進(jìn)入 renewExpiration()
private void renewExpiration() {
    ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    //如果緩存不存在，那不再鎖續(xù)期
    if (ee == null) {
        return;
    }
    
    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
            if (ent == null) {
                return;
            }
            Long threadId = ent.getFirstThreadId();
            if (threadId == null) {
                return;
            }
            
            //執(zhí)行l(wèi)ua 進(jìn)行續(xù)期
            RFuture<Boolean> future = renewExpirationAsync(threadId);
            future.onComplete((res, e) -> {
                if (e != null) {
                    log.error("Can't update lock " + getName() + " expiration", e);
                    return;
                }
                
                if (res) {
                    //延期成功，繼續(xù)循環(huán)操作
                    renewExpiration();
                }
            });
        }
        //每隔internalLockLeaseTime/3=10秒檢查一次
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
    
    ee.setTimeout(task);
}
 
//lua腳本 執(zhí)行包裝好的lua腳本進(jìn)行key續(xù)期
protected 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()),
            internalLockLeaseTime, getLockName(threadId));
}

// 鎖釋放
public void unlock() {
    try {
        get(unlockAsync(Thread.currentThread().getId()));
    } catch (RedisException e) {
        if (e.getCause() instanceof IllegalMonitorStateException) {
            throw (IllegalMonitorStateException) e.getCause();
        } else {
            throw e;
        }
    }
}
 
// 進(jìn)入 unlockAsync(Thread.currentThread().getId()) 方法 入?yún)⑹钱?dāng)前線程的id
public RFuture<Void> unlockAsync(long threadId) {
    RPromise<Void> result = new RedissonPromise<Void>();
    //執(zhí)行l(wèi)ua腳本 刪除key
    RFuture<Boolean> future = unlockInnerAsync(threadId);
    //回調(diào)函數(shù)
    future.onComplete((opStatus, e) -> {
        // 無(wú)論執(zhí)行l(wèi)ua腳本是否成功 執(zhí)行cancelExpirationRenewal(threadId) 方法來(lái)刪除EXPIRATION_RENEWAL_MAP中的緩存
        cancelExpirationRenewal(threadId);
 
        if (e != null) {
            result.tryFailure(e);
            return;
        }
 
        if (opStatus == null) {
            IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: "
                    + id + " thread-id: " + threadId);
            result.tryFailure(cause);
            return;
        }
 
        result.trySuccess(null);
    });
 
    return result;
}
 
// 此方法會(huì)停止 watch dog 機(jī)制
void cancelExpirationRenewal(Long threadId) {
    ExpirationEntry task = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (task == null) {
        return;
    }
    
    if (threadId != null) {
        task.removeThreadId(threadId);
    }
 
    if (threadId == null || task.hasNoThreads()) {
        Timeout timeout = task.getTimeout();
        if (timeout != null) {
            timeout.cancel();
        }
        EXPIRATION_RENEWAL_MAP.remove(getEntryName());
    }
}

EXPIRATION_RENEWAL_MAP.get(getEntryName());
if (ent == null) {
    return;
}