<!-- JDK 1.8+ compatible -->
<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.9.0</version>
</dependency> 

@Test
public void testRedLock() {
    Config config = new Config();
    config.useSingleServer().setAddress("redis://127.0.0.1:6379");
    RedissonClient client1 = Redisson.create(config);
    RLock lock1 = client1.getLock("lock1");
    RLock lock2 = client1.getLock("lock2");
    RLock lock3 = client1.getLock("lock3");
    RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
    try {
        /**
         * 4.嘗試獲取鎖
         * redLock.tryLock((long)waitTimeout, (long)leaseTime, TimeUnit.SECONDS)
         * waitTimeout 嘗試獲取鎖的最大等待時間，超過這個值，則認為獲取鎖失敗
         * leaseTime   鎖的持有時間,超過這個時間鎖會自動失效（值應設置為大于業(yè)務處理的時間，確保在鎖有效期內業(yè)務能處理完）
         */
        // 嘗試加鎖，最多等待100秒，上鎖以后10秒自動解鎖
        boolean res = redLock.tryLock(100, 10, TimeUnit.SECONDS);
        if (res) {
            //成功獲得鎖，在這里處理業(yè)務
            System.out.println("成功獲取到鎖...");
        }
    } catch (Exception e) {
        throw new RuntimeException("aquire lock fail");
    } finally {
        // 無論如何, 最后都要解鎖
        redLock.unlock();
    }
}

protected int failedLocksLimit() {
    return locks.size() - minLocksAmount(locks);
}
protected int minLocksAmount(final List<RLock> locks) {
    // 最小的獲取鎖成功數(shù)：n/2 + 1。 過半機制
    return locks.size()/2 + 1;
}

protected int failedLocksLimit() {
    return 0;
}

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
//        try {
//            return tryLockAsync(waitTime, leaseTime, unit).get();
//        } catch (ExecutionException e) {
//            throw new IllegalStateException(e);
//        }
    long newLeaseTime = -1;
    if (leaseTime > 0) {
        if (waitTime > 0) {
            newLeaseTime = unit.toMillis(waitTime)*2;
        } else {
            newLeaseTime = unit.toMillis(leaseTime);
        }
    }
    // 獲取當前系統(tǒng)時間，單位：毫秒
    long time = System.currentTimeMillis();
    long remainTime = -1;
    if (waitTime > 0) {
        remainTime = unit.toMillis(waitTime);
    }
    long lockWaitTime = calcLockWaitTime(remainTime);
    // 允許加鎖失敗節(jié)點個數(shù)限制（N - ( N / 2 + 1 )）
    // 假設有三個redis節(jié)點，則failedLocksLimit = 1
    int failedLocksLimit = failedLocksLimit();
    // 存放調用tryLock()方法加鎖成功的那些redis節(jié)點
    List<RLock> acquiredLocks = new ArrayList<>(locks.size());
    // 循環(huán)所有節(jié)點，通過EVAL命令執(zhí)行LUA腳本進行加鎖
    for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
        // 獲取到其中一個redis實例
        RLock lock = iterator.next();
        String lockName = lock.getName();
        System.out.println("lockName = " + lockName + "正在嘗試加鎖...");
        boolean lockAcquired;
        try {
            // 未指定鎖超時時間和獲取鎖等待時間的情況
            if (waitTime <= 0 && leaseTime <= 0) {
                // 調用tryLock()嘗試加鎖
                lockAcquired = lock.tryLock();
            } else {
                // 指定了超時時間的情況,重新計算獲取鎖的等待時間
                long awaitTime = Math.min(lockWaitTime, remainTime);
                // 調用tryLock()嘗試加鎖
                lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
            }
        } catch (RedisResponseTimeoutException e) {
            // 如果拋出RedisResponseTimeoutException異常，為了防止加鎖成功，但是響應失敗，需要解鎖所有節(jié)點
            unlockInner(Arrays.asList(lock));
            // 表示獲取鎖失敗
            lockAcquired = false;
        } catch (Exception e) {
            // 表示獲取鎖失敗
            lockAcquired = false;
        }
        if (lockAcquired) {
            // 如果當前redis節(jié)點加鎖成功，則加入到acquiredLocks集合中
            acquiredLocks.add(lock);
        } else {
            // 計算已經(jīng)申請鎖失敗的節(jié)點是否已經(jīng)到達 允許加鎖失敗節(jié)點個數(shù)限制 （N-(N/2+1)）, 如果已經(jīng)到達，就認定最終申請鎖失敗，則沒有必要繼續(xù)從后面的節(jié)點申請了。因為 Redlock 算法要求至少N/2+1 個節(jié)點都加鎖成功，才算最終的鎖申請成功
            if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                break;
            }
            if (failedLocksLimit == 0) {
                unlockInner(acquiredLocks);
                if (waitTime <= 0) {
                    return false;
                }
                failedLocksLimit = failedLocksLimit();
                acquiredLocks.clear();
                // reset iterator
                while (iterator.hasPrevious()) {
                    iterator.previous();
                }
            } else {
                failedLocksLimit--;
            }
        }
        // 計算 目前從各個節(jié)點獲取鎖已經(jīng)消耗的總時間，如果已經(jīng)等于最大等待時間，則認定最終申請鎖失敗，返回false
        if (remainTime > 0) {
            // remainTime: 鎖剩余時間，這個時間是某個客戶端向所有redis節(jié)點申請獲取鎖的總等待時間, 獲取鎖的中耗時時間不能大于這個時間。
            // System.currentTimeMillis() - time: 這個計算出來的就是當前redis節(jié)點獲取鎖消耗的時間
            remainTime -= System.currentTimeMillis() - time;
            // 重置time為當前時間，因為下一次循環(huán)的時候，方便計算下一個redis節(jié)點獲取鎖消耗的時間
            time = System.currentTimeMillis();
            // 鎖剩余時間減到0了，說明達到最大等待時間，加鎖超時，認為獲取鎖失敗，需要對成功加鎖集合 acquiredLocks 中的所有鎖執(zhí)行鎖釋放
            if (remainTime <= 0) {
                unlockInner(acquiredLocks);
                // 直接返回false，獲取鎖失敗
                return false;
            }
        }
    }
    if (leaseTime > 0) {
        // 重置鎖過期時間
        acquiredLocks.stream()
                .map(l -> (RedissonBaseLock) l)
                .map(l -> l.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS))
                .forEach(f -> f.toCompletableFuture().join());
    }
    // 如果邏輯正常執(zhí)行完則認為最終申請鎖成功，返回true
    return true;
}