RLock lock1 = redisson1.getLock("lock1");
RLock lock2 = redisson2.getLock("lock2");
RLock lock3 = redisson3.getLock("lock3");

RLock redLock = anyRedisson.getRedLock(lock1, lock2, lock3);

// traditional lock method
redLock.lock();

// or acquire lock and automatically unlock it after 10 seconds
redLock.lock(10, TimeUnit.SECONDS);

// or wait for lock aquisition up to 100 seconds 
// and automatically unlock it after 10 seconds
boolean res = redLock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       redLock.unlock();
   }
}

public class RedissonRedLock extends RedissonMultiLock {
    public RedissonRedLock(RLock... locks) {
        super(locks);
    }

    /**
     * Number of times locks can fail, number of locks - minimum number of successful clients
     */
    @Override
    protected int failedLocksLimit() {
        return locks.size() - minLocksAmount(locks);
    }
    
    /**
     * Number of locks / 2 + 1, e.g. 3 clients lock, then at least 2 clients are required to lock successfully
     */
    protected int minLocksAmount(final List<RLock> locks) {
        return locks.size()/2 + 1;
    }

    /** 
     * Calculates the time-out for locks held together by multiple clients, and the wait time for each client
     * remainTime Default 4.5s
     */
    @Override
    protected long calcLockWaitTime(long remainTime) {
        return Math.max(remainTime / locks.size(), 1);
    }
    
    @Override
    public void unlock() {
        unlockInner(locks);
    }

}

```java
public class RedissonMultiLock implements Lock {

    final List<RLock> locks = new ArrayList<RLock>();

    public RedissonMultiLock(RLock... locks) {
        if (locks.length == 0) {
            throw new IllegalArgumentException("Lock objects are not defined");
        }
        this.locks.addAll(Arrays.asList(locks));
    }

    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long newLeaseTime = -1;
        if (leaseTime != -1) {
            // If the wait time is set, the wait time will be * 2
            newLeaseTime = unit.toMillis(waitTime)*2;
        }
        
        // time For the current timestamp
        long time = System.currentTimeMillis();
        long remainTime = -1;
        if (waitTime != -1) {
            remainTime = unit.toMillis(waitTime);
        }
        // Calculate the wait time for the lock, RedLock Medium: If remainTime=-1，that lockWaitTime 1
        long lockWaitTime = calcLockWaitTime(remainTime);
        
        // RedLock in failedLocksLimit mean n/2 + 1
        int failedLocksLimit = failedLocksLimit();
        List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size());
        // Loop each redis Client, to get the lock
        for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
            RLock lock = iterator.next();
            boolean lockAcquired;
            try {
                // call tryLock Method to acquire a lock, if the lock is acquired successfully, lockAcquired=true
                if (waitTime == -1 && leaseTime == -1) {
                    lockAcquired = lock.tryLock();
                } else {
                    long awaitTime = Math.min(lockWaitTime, remainTime);
                    lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
                }
            } catch (Exception e) {
                lockAcquired = false;
            }
            
            // If the lock is acquired successfully, add the lock to the list In collection
            if (lockAcquired) {
                acquiredLocks.add(lock);
            } else {
                // If acquiring a lock fails, determine if the number of failures equals the limit of failures
                // For example, three redis Client, can fail at most once
                // Here locks.size = 3, 3-x=1，Explain that once you've succeeded twice you can go straight ahead break Drop Cycle
                if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                    break;
                }

                // If the maximum number of failures equals 0
                if (failedLocksLimit == 0) {
                    // Release all locks, RedLock Failed to lock
                    unlockInner(acquiredLocks);
                    if (waitTime == -1 && leaseTime == -1) {
                        return false;
                    }
                    failedLocksLimit = failedLocksLimit();
                    acquiredLocks.clear();
                    // Reset Iterator Retry to Acquire Lock Again
                    while (iterator.hasPrevious()) {
                        iterator.previous();
                    }
                } else {
                    // Limit the number of failures by one
                    // Like three redis Instance, the maximum limit is 1, if the first one is traversed redis Instance, failed, then failedLocksLimit Will be reduced to 0
                    // If failedLocksLimit Will walk up if Logic, release all locks, then return false
                    failedLocksLimit--;
                }
            }
            
            if (remainTime != -1) {
                remainTime -= (System.currentTimeMillis() - time);
                time = System.currentTimeMillis();
                if (remainTime <= 0) {
                    unlockInner(acquiredLocks);
                    return false;
                }
            }
        }

        if (leaseTime != -1) {
            List<RFuture<Boolean>> futures = new ArrayList<RFuture<Boolean>>(acquiredLocks.size());
            for (RLock rLock : acquiredLocks) {
                RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
                futures.add(future);
            }
            
            for (RFuture<Boolean> rFuture : futures) {
                rFuture.syncUninterruptibly();
            }
        }
        
        return true;
    }
}