RedissonMultiLock (Redisson 3.11.6 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 lock independently of state
`RFuture<Boolean>`	`forceUnlockAsync()` Unlocks the lock independently of 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 this lock is held by the current thread
`boolean`	`isLocked()` Checks if this lock locked by any thread
`RFuture<Boolean>`	`isLockedAsync()` Checks if this lock locked by any thread
`void`	`lock()`
`void`	`lock(long leaseTime, TimeUnit unit)` Acquires the lock.
`RFuture<Void>`	`lockAsync()` Acquires the lock.
`RFuture<Void>`	`lockAsync(long threadId)` Acquires the lock by thread with specified `threadId`.
`RFuture<Void>`	`lockAsync(long leaseTime, TimeUnit unit)` Acquires the lock.
`RFuture<Void>`	`lockAsync(long leaseTime, TimeUnit unit, long threadId)` Acquires the lock by thread with specified `threadId`.
`void`	`lockInterruptibly()`
`void`	`lockInterruptibly(long leaseTime, TimeUnit unit)` Acquires the lock.
`Condition`	`newCondition()`
`long`	`remainTimeToLive()` Remaining time to live of this lock
`RFuture<Long>`	`remainTimeToLiveAsync()` Remaining time to live of this lock
`boolean`	`tryLock()`
`boolean`	`tryLock(long waitTime, long leaseTime, TimeUnit unit)` Returns `true` as soon as the lock is acquired.
`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.
`RFuture<Boolean>`	`tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId)` Tries to acquire the lock by thread with specified `threadId`.
`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.
    If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired. If the lock is acquired, it is held until unlock is invoked, or until leaseTime milliseconds have passed since the lock was granted - whichever comes first.
    
    Specified by:
    
    lock in interface RLock
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after granting it, before automatically releasing it if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit of the leaseTime argument
  - lockAsync
```
public RFuture<Void> lockAsync(long leaseTime,
                               TimeUnit unit)
```
    Description copied from interface: RLockAsync
    
    Acquires the lock.
    If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired. If the lock is acquired, it is held until unlock is invoked, or until leaseTime milliseconds have passed since the lock was granted - whichever comes first.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after granting it, before automatically releasing it if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit of the leaseTime argument
    
    Returns:
    
    void
  - lockAsync
```
public RFuture<Void> lockAsync(long leaseTime,
                               TimeUnit unit,
                               long threadId)
```
    Description copied from interface: RLockAsync
    
    Acquires the lock by thread with specified threadId.
    If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired. If the lock is acquired, it is held until unlock is invoked, or until leaseTime milliseconds have passed since the lock was granted - whichever comes first.
    
    Specified by:
    
    lockAsync in interface RLockAsync
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after granting it, before automatically releasing it if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit of the leaseTime argument
    
    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.
    If the lock is not available then the current thread becomes disabled for thread scheduling purposes and lies dormant until the lock has been acquired. If the lock is acquired, it is held until unlock is invoked, or until leaseTime have passed since the lock was granted - whichever comes first.
    
    Specified by:
    
    lockInterruptibly in interface RLock
    
    Parameters:
    
    leaseTime - the maximum time to hold the lock after granting it, before automatically releasing it if it hasn't already been released by invoking unlock. If leaseTime is -1, hold the lock until explicitly unlocked.
    
    unit - the time unit of the leaseTime argument
    
    Throws:
    
    InterruptedException - - if the thread is interrupted before or during this method.
  - 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
    
    Returns true as soon as the lock is acquired. If the lock is currently held by another thread in this or any other process in the distributed system this method keeps trying to acquire the lock for up to waitTime before giving up and returning false. If the lock is acquired, it is held until unlock is invoked, or until leaseTime have passed since the lock was granted - whichever comes first.
    
    Specified by:
    
    tryLock in interface RLock
    
    Parameters:
    
    waitTime - the maximum time to aquire the lock
    
    leaseTime - lease time
    
    unit - time unit
    
    Returns:
    
    true if lock has been successfully acquired
    
    Throws:
    
    InterruptedException - - if the thread is interrupted before or during this method.
  - 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. If the lock is not available waits up to specified waitTime time interval to acquire it. Lock will be release 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. If the lock is not available waits up to specified waitTime time interval to acquire it. Lock will be release 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
    
    Returns:
    
    true if lock acquired otherwise false
  - 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 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.
    
    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 specified threadId.
    
    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. If the lock is not available waits up to specified waitTime time interval to acquire it.
    
    Specified by:
    
    tryLockAsync in interface RLockAsync
    
    Parameters:
    
    waitTime - interval to acquire lock
    
    unit - the time unit of the waitTime argument
    
    Returns:
    
    true if lock acquired otherwise false
  - 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 lock independently of 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 this 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 this 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 this lock is held by the current thread
    
    Specified by:
    
    isHeldByThread in interface RLock
    
    Parameters:
    
    threadId - Thread ID of locking thread
    
    Returns:
    
    true if held by given thread 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 this 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 this 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