RLockRx (Redisson 3.11.6 API)

```
public interface RLockRx
```
RxJava2 interface for Lock object

Author:

Nikita Koksharov

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`io.reactivex.Single<Boolean>`	`forceUnlock()` Unlocks the lock independently of state
`io.reactivex.Single<Integer>`	`getHoldCount()` Number of holds on this lock by the current thread
`String`	`getName()` Returns name of object
`io.reactivex.Single<Boolean>`	`isLocked()` Checks if this lock locked by any thread
`io.reactivex.Completable`	`lock()` Acquires the lock.
`io.reactivex.Completable`	`lock(long threadId)` Acquires the lock by thread with specified `threadId`.
`io.reactivex.Completable`	`lock(long leaseTime, TimeUnit unit)` Acquires the lock.
`io.reactivex.Completable`	`lock(long leaseTime, TimeUnit unit, long threadId)` Acquires the lock by thread with specified `threadId`.
`io.reactivex.Single<Long>`	`remainTimeToLive()` Remaining time to live of this lock
`io.reactivex.Single<Boolean>`	`tryLock()` Tries to acquire the lock.
`io.reactivex.Single<Boolean>`	`tryLock(long threadId)` Tries to acquire the lock by thread with specified `threadId`.
`io.reactivex.Single<Boolean>`	`tryLock(long waitTime, long leaseTime, TimeUnit unit)` Tries to acquire the lock.
`io.reactivex.Single<Boolean>`	`tryLock(long waitTime, long leaseTime, TimeUnit unit, long threadId)` Tries to acquire the lock by thread with specified `threadId`.
`io.reactivex.Single<Boolean>`	`tryLock(long waitTime, TimeUnit unit)` Tries to acquire the lock.
`io.reactivex.Completable`	`unlock()` Unlocks the lock
`io.reactivex.Completable`	`unlock(long threadId)` Unlocks the lock.

- Method Detail
  - getName
```
String getName()
```
    Returns name of object
    
    Returns:
    
    name - name of object
  - forceUnlock
```
io.reactivex.Single<Boolean> forceUnlock()
```
    Unlocks the lock independently of state
    
    Returns:
    
    true if unlocked otherwise false
  - unlock
```
io.reactivex.Completable unlock()
```
    Unlocks the lock
    
    Returns:
    
    void
  - unlock
```
io.reactivex.Completable unlock(long threadId)
```
    Unlocks the lock. Throws IllegalMonitorStateException if lock isn't locked by thread with specified threadId.
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    void
  - tryLock
```
io.reactivex.Single<Boolean> tryLock()
```
    Tries to acquire the lock.
    
    Returns:
    
    true if lock acquired otherwise false
  - lock
```
io.reactivex.Completable lock()
```
    Acquires the lock.
    
    Returns:
    
    void
  - lock
```
io.reactivex.Completable lock(long threadId)
```
    Acquires the lock by thread with specified threadId.
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    void
  - lock
```
io.reactivex.Completable lock(long leaseTime,
                              TimeUnit unit)
```
    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.
    
    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
  - lock
```
io.reactivex.Completable lock(long leaseTime,
                              TimeUnit unit,
                              long threadId)
```
    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.
    
    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
  - tryLock
```
io.reactivex.Single<Boolean> tryLock(long threadId)
```
    Tries to acquire the lock by thread with specified threadId.
    
    Parameters:
    
    threadId - id of thread
    
    Returns:
    
    true if lock acquired otherwise false
  - tryLock
```
io.reactivex.Single<Boolean> tryLock(long waitTime,
                                     TimeUnit unit)
```
    Tries to acquire the lock. If the lock is not available waits up to specified waitTime time interval to acquire it.
    
    Parameters:
    
    waitTime - interval to acquire lock
    
    unit - the time unit of the waitTime argument
    
    Returns:
    
    true if lock acquired otherwise false
  - tryLock
```
io.reactivex.Single<Boolean> tryLock(long waitTime,
                                     long leaseTime,
                                     TimeUnit unit)
```
    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.
    
    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
  - tryLock
```
io.reactivex.Single<Boolean> tryLock(long waitTime,
                                     long leaseTime,
                                     TimeUnit unit,
                                     long threadId)
```
    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.
    
    Parameters:
    
    threadId - id of thread
    
    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
  - getHoldCount
```
io.reactivex.Single<Integer> getHoldCount()
```
    Number of holds on this lock by the current thread
    
    Returns:
    
    holds or 0 if this lock is not held by current thread
  - isLocked
```
io.reactivex.Single<Boolean> isLocked()
```
    Checks if this lock locked by any thread
    
    Returns:
    
    true if locked otherwise false
  - remainTimeToLive
```
io.reactivex.Single<Long> remainTimeToLive()
```
    Remaining time to live of this lock
    
    Returns:
    
    time in milliseconds -2 if the lock does not exist. -1 if the lock exists but has no associated expire.

Interface RLockRx

Method Summary

Method Detail

getName

forceUnlock

unlock

unlock

tryLock

lock

lock

lock

lock

tryLock

tryLock

tryLock

tryLock

getHoldCount

isLocked

remainTimeToLive