RedissonMultiLock (Redisson 3.12.4 API)

java.lang.Object
- org.redisson.RedissonMultiLock

All Implemented Interfaces:

Lock, RLock, RLockAsync

Direct Known Subclasses:

RedissonRedLock
```
public class RedissonMultiLock
extends Object
implements RLock
```
Groups multiple independent locks and manages them as one lock.

Author:

Nikita Koksharov

Constructor Summary

Constructors
Constructor and Description

RedissonMultiLock(RLock... locks)
Creates instance with multiple RLock objects.

Constructors
Constructor and Description
`RedissonMultiLock(RLock... locks)` Creates instance with multiple `RLock` objects.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected long`	`calcLockWaitTime(long remainTime)`
`protected int`	`failedLocksLimit()`
`boolean`	`forceUnlock()` Unlocks the lock independently of its state
`RFuture<Boolean>`	`forceUnlockAsync()` Unlocks the lock independently of its state
`int`	`getHoldCount()` Number of holds on this lock by the current thread
`RFuture<Integer>`	`getHoldCountAsync()` Number of holds on this lock by the current thread
`String`	`getName()` Returns name of object
`boolean`	`isHeldByCurrentThread()` Checks if this lock is held by the current thread
`boolean`	`isHeldByThread(long threadId)` Checks if the lock is held by thread with defined `threadId`
`boolean`	`isLocked()` Checks if the lock locked by any thread
`RFuture<Boolean>`	`isLockedAsync()` Checks if the lock locked by any thread
`void`	`lock()`
`void`	`lock(long leaseTime, TimeUnit unit)` Acquires the lock with defined `leaseTime`.
`RFuture<Void>`	`lockAsync()` Acquires the lock.
`RFuture<Void>`	`lockAsync(long threadId)` Acquires the lock by thread with defined `threadId`.
`RFuture<Void>`	`lockAsync(long leaseTime, TimeUnit unit)` Acquires the lock with defined `leaseTime`.
`RFuture<Void>`	`lockAsync(long leaseTime, TimeUnit unit, long threadId)` Acquires the lock with defined `leaseTime` and `threadId`.
`void`	`lockInterruptibly()`
`void`	`lockInterruptibly(long leaseTime, TimeUnit unit)` Acquires the lock with defined `leaseTime`.
`Condition`	`newCondition()`
`long`	`remainTimeToLive()` Remaining time to live of the lock
`RFuture<Long>`	`remainTimeToLiveAsync()` Remaining time to live of the lock
`boolean`	`tryLock()`
`boolean`	`tryLock(long waitTime, long leaseTime, TimeUnit unit)` Tries to acquire the lock with defined `leaseTime`.
`boolean`	`tryLock(long waitTime, TimeUnit unit)`
`RFuture<Boolean>`	`tryLockAsync()` Tries to acquire the lock.
`RFuture<Boolean>`	`tryLockAsync(long threadId)` Tries to acquire the lock by thread with specified `threadId`.
`RFuture<Boolean>`	`tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)` Tries to acquire the lock with defined `leaseTime`.
`RFuture<Boolean>`	`tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId)` Tries to acquire the lock by thread with specified `threadId` and `leaseTime`.
`protected void`	`tryLockAsync(long threadId, long leaseTime, TimeUnit unit, long waitTime, RPromise<Void> result)`
`RFuture<Boolean>`	`tryLockAsync(long waitTime, TimeUnit unit)` Tries to acquire the lock.
`void`	`unlock()`
`RFuture<Void>`	`unlockAsync()` Unlocks the lock
`RFuture<Void>`	`unlockAsync(long threadId)` Unlocks the lock.
`protected void`	`unlockInner(Collection<RLock> locks)`
`protected RFuture<Void>`	`unlockInnerAsync(Collection<RLock> locks, long threadId)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RedissonMultiLock
```
public RedissonMultiLock(RLock... locks)
```
    Creates instance with multiple RLock objects. Each RLock object could be created by own Redisson instance.
    
    Parameters:
    
    locks - - array of locks
- Method Detail
  - lock
```
public void lock()
```
    Specified by:
    
    lock in interface Lock
  - lock
```
public void lock(long leaseTime,
                 TimeUnit unit)
```
    Description copied from interface: RLock
    
    Acquires the lock with defined leaseTime. Waits if necessary until lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    lock in interface RLock
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after it's acquisition, if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit
  - lockAsync
```
public RFuture<Void> lockAsync(long leaseTime,
                               TimeUnit unit)
```
    Description copied from interface: RLockAsync
    
    Acquires the lock with defined leaseTime. Waits if necessary until lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after it's acquisition, if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit
    
    Returns:
    
    void
  - lockAsync
```
public RFuture<Void> lockAsync(long leaseTime,
                               TimeUnit unit,
                               long threadId)
```
    Description copied from interface: RLockAsync
    
    Acquires the lock with defined leaseTime and threadId. Waits if necessary until lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after it's acquisition, if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit
    
    threadId - id of thread
    
    Returns:
    
    void
  - tryLockAsync
```
protected void tryLockAsync(long threadId,
                            long leaseTime,
                            TimeUnit unit,
                            long waitTime,
                            RPromise<Void> result)
```
  - lockInterruptibly
```
public void lockInterruptibly()
                       throws InterruptedException
```
    Specified by:
    
    lockInterruptibly in interface Lock
    
    Throws:
    
    InterruptedException
  - lockInterruptibly
```
public void lockInterruptibly(long leaseTime,
                              TimeUnit unit)
                       throws InterruptedException
```
    Description copied from interface: RLock
    
    Acquires the lock with defined leaseTime. Waits if necessary until lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    lockInterruptibly in interface RLock
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after it's acquisition, if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit
    
    Throws:
    
    InterruptedException - - if the thread is interrupted
  - tryLock
```
public boolean tryLock()
```
    Specified by:
    
    tryLock in interface Lock
  - unlockInner
```
protected void unlockInner(Collection<RLock> locks)
```
  - unlockInnerAsync
```
protected RFuture<Void> unlockInnerAsync(Collection<RLock> locks,
                                         long threadId)
```
  - tryLock
```
public boolean tryLock(long waitTime,
                       TimeUnit unit)
                throws InterruptedException
```
    Specified by:
    
    tryLock in interface Lock
    
    Throws:
    
    InterruptedException
  - failedLocksLimit
```
protected int failedLocksLimit()
```
  - tryLock
```
public boolean tryLock(long waitTime,
                       long leaseTime,
                       TimeUnit unit)
                throws InterruptedException
```
    Description copied from interface: RLock
    
    Tries to acquire the lock with defined leaseTime. Waits up to defined waitTime if necessary until the lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    tryLock in interface RLock
    
    Parameters:
    
    waitTime - the maximum time to acquire the lock
    
    leaseTime - lease time
    
    unit - time unit
    
    Returns:
    
    true if lock is successfully acquired, otherwise false if lock is already set.
    
    Throws:
    
    InterruptedException - - if the thread is interrupted
  - tryLockAsync
```
public RFuture<Boolean> tryLockAsync(long waitTime,
                                     long leaseTime,
                                     TimeUnit unit,
                                     long threadId)
```
    Description copied from interface: RLockAsync
    
    Tries to acquire the lock by thread with specified threadId and leaseTime. Waits up to defined waitTime if necessary until the lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Parameters:
    
    waitTime - time interval to acquire lock
    
    leaseTime - time interval after which lock will be released automatically
    
    unit - the time unit of the waitTime and leaseTime arguments
    
    threadId - id of thread
    
    Returns:
    
    true if lock acquired otherwise false
  - tryLockAsync
```
public RFuture<Boolean> tryLockAsync(long waitTime,
                                     long leaseTime,
                                     TimeUnit unit)
```
    Description copied from interface: RLockAsync
    
    Tries to acquire the lock with defined leaseTime. Waits up to defined waitTime if necessary until the lock became available. Lock will be released automatically after defined leaseTime interval.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Parameters:
    
    waitTime - the maximum time to acquire the lock
    
    leaseTime - lease time
    
    unit - time unit
    
    Returns:
    
    true if lock is successfully acquired, otherwise false if lock is already set.
  - calcLockWaitTime
```
protected long calcLockWaitTime(long remainTime)
```
  - unlockAsync
```
public RFuture<Void> unlockAsync(long threadId)
```
    Description copied from interface: RLockAsync
    
    Unlocks the lock. Throws IllegalMonitorStateException if lock isn't locked by thread with specified threadId.
    
    Specified by:
    
    unlockAsync in interface RLockAsync
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    void
  - unlock
```
public void unlock()
```
    Specified by:
    
    unlock in interface Lock
  - newCondition
```
public Condition newCondition()
```
    Specified by:
    
    newCondition in interface Lock
  - forceUnlockAsync
```
public RFuture<Boolean> forceUnlockAsync()
```
    Description copied from interface: RLockAsync
    
    Unlocks the lock independently of its state
    
    Specified by:
    
    forceUnlockAsync in interface RLockAsync
    
    Returns:
    
    true if lock existed and now unlocked otherwise false
  - unlockAsync
```
public RFuture<Void> unlockAsync()
```
    Description copied from interface: RLockAsync
    
    Unlocks the lock
    
    Specified by:
    
    unlockAsync in interface RLockAsync
    
    Returns:
    
    void
  - tryLockAsync
```
public RFuture<Boolean> tryLockAsync()
```
    Description copied from interface: RLockAsync
    
    Tries to acquire the lock.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Returns:
    
    true if lock acquired otherwise false
  - lockAsync
```
public RFuture<Void> lockAsync()
```
    Description copied from interface: RLockAsync
    
    Acquires the lock. Waits if necessary until lock became available.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Returns:
    
    void
  - lockAsync
```
public RFuture<Void> lockAsync(long threadId)
```
    Description copied from interface: RLockAsync
    
    Acquires the lock by thread with defined threadId. Waits if necessary until lock became available.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    void
  - tryLockAsync
```
public RFuture<Boolean> tryLockAsync(long threadId)
```
    Description copied from interface: RLockAsync
    
    Tries to acquire the lock by thread with specified threadId.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    true if lock acquired otherwise false
  - tryLockAsync
```
public RFuture<Boolean> tryLockAsync(long waitTime,
                                     TimeUnit unit)
```
    Description copied from interface: RLockAsync
    
    Tries to acquire the lock. Waits up to defined waitTime if necessary until the lock became available.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Parameters:
    
    waitTime - the maximum time to acquire the lock
    
    unit - time unit
    
    Returns:
    
    true if lock is successfully acquired, otherwise false if lock is already set.
  - getHoldCountAsync
```
public RFuture<Integer> getHoldCountAsync()
```
    Description copied from interface: RLockAsync
    
    Number of holds on this lock by the current thread
    
    Specified by:
    
    getHoldCountAsync in interface RLockAsync
    
    Returns:
    
    holds or 0 if this lock is not held by current thread
  - getName
```
public String getName()
```
    Description copied from interface: RLock
    
    Returns name of object
    
    Specified by:
    
    getName in interface RLock
    
    Returns:
    
    name - name of object
  - forceUnlock
```
public boolean forceUnlock()
```
    Description copied from interface: RLock
    
    Unlocks the lock independently of its state
    
    Specified by:
    
    forceUnlock in interface RLock
    
    Returns:
    
    true if lock existed and now unlocked otherwise false
  - isLocked
```
public boolean isLocked()
```
    Description copied from interface: RLock
    
    Checks if the lock locked by any thread
    
    Specified by:
    
    isLocked in interface RLock
    
    Returns:
    
    true if locked otherwise false
  - isLockedAsync
```
public RFuture<Boolean> isLockedAsync()
```
    Description copied from interface: RLockAsync
    
    Checks if the lock locked by any thread
    
    Specified by:
    
    isLockedAsync in interface RLockAsync
    
    Returns:
    
    true if locked otherwise false
  - isHeldByThread
```
public boolean isHeldByThread(long threadId)
```
    Description copied from interface: RLock
    
    Checks if the lock is held by thread with defined threadId
    
    Specified by:
    
    isHeldByThread in interface RLock
    
    Parameters:
    
    threadId - Thread ID of locking thread
    
    Returns:
    
    true if held by thread with given id otherwise false
  - isHeldByCurrentThread
```
public boolean isHeldByCurrentThread()
```
    Description copied from interface: RLock
    
    Checks if this lock is held by the current thread
    
    Specified by:
    
    isHeldByCurrentThread in interface RLock
    
    Returns:
    
    true if held by current thread otherwise false
  - getHoldCount
```
public int getHoldCount()
```
    Description copied from interface: RLock
    
    Number of holds on this lock by the current thread
    
    Specified by:
    
    getHoldCount in interface RLock
    
    Returns:
    
    holds or 0 if this lock is not held by current thread
  - remainTimeToLiveAsync
```
public RFuture<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RLockAsync
    
    Remaining time to live of the lock
    
    Specified by:
    
    remainTimeToLiveAsync in interface RLockAsync
    
    Returns:
    
    time in milliseconds -2 if the lock does not exist. -1 if the lock exists but has no associated expire.
  - remainTimeToLive
```
public long remainTimeToLive()
```
    Description copied from interface: RLock
    
    Remaining time to live of the lock
    
    Specified by:
    
    remainTimeToLive in interface RLock
    
    Returns:
    
    time in milliseconds -2 if the lock does not exist. -1 if the lock exists but has no associated expire.

Class RedissonMultiLock

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RedissonMultiLock

Method Detail

lock

lock

lockAsync

lockAsync

tryLockAsync

lockInterruptibly

lockInterruptibly

tryLock

unlockInner

unlockInnerAsync

tryLock

failedLocksLimit

tryLock

tryLockAsync

tryLockAsync

calcLockWaitTime

unlockAsync

unlock

newCondition

forceUnlockAsync

unlockAsync

tryLockAsync

lockAsync

lockAsync

tryLockAsync

tryLockAsync

getHoldCountAsync

getName

forceUnlock

isLocked

isLockedAsync

isHeldByThread

isHeldByCurrentThread

getHoldCount

remainTimeToLiveAsync

remainTimeToLive