org.redisson.core

Interface RLock

All Superinterfaces:

Lock, RExpirable, RExpirableAsync, RObject, RObjectAsync

All Known Implementing Classes:

RedissonFairLock, RedissonLock, RedissonReadLock, RedissonWriteLock

public interface RLock
extends Lock, RExpirable

Distributed implementation of Lock Implements reentrant lock. Use getHoldCount() to get a holds count.

Author:

Nikita Koksharov

Method Summary

Methods

Modifier and Type	Method and Description
void	forceUnlock() Unlocks lock independently of state
io.netty.util.concurrent.Future<Boolean>	forceUnlockAsync()
int	getHoldCount() Number of holds on this lock by the current thread
boolean	isHeldByCurrentThread() Checks if this lock is held by the current thread
boolean	isLocked() Checks if this lock locked by any thread
void	lock(long leaseTime, TimeUnit unit) Acquires the lock.
io.netty.util.concurrent.Future<Void>	lockAsync()
io.netty.util.concurrent.Future<Void>	lockAsync(long leaseTime, TimeUnit unit)
void	lockInterruptibly(long leaseTime, TimeUnit unit) Acquires the lock.
boolean	tryLock(long waitTime, long leaseTime, TimeUnit unit) Returns true as soon as the lock is acquired.
io.netty.util.concurrent.Future<Boolean>	tryLockAsync()
io.netty.util.concurrent.Future<Boolean>	tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)
io.netty.util.concurrent.Future<Boolean>	tryLockAsync(long waitTime, TimeUnit unit)
io.netty.util.concurrent.Future<Void>	unlockAsync()

Methods inherited from interface java.util.concurrent.locks.Lock

lock, lockInterruptibly, newCondition, tryLock, tryLock, unlock

Methods inherited from interface org.redisson.core.RExpirable

clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.core.RObject

delete, getName, isExists, migrate, move, rename, renamenx

Methods inherited from interface org.redisson.core.RExpirableAsync

clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.core.RObjectAsync

deleteAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

Method Detail

lockInterruptibly

void lockInterruptibly(long leaseTime,
                     TimeUnit unit)
                       throws InterruptedException

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.

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

boolean tryLock(long waitTime,
              long leaseTime,
              TimeUnit unit)
                throws InterruptedException

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.

Parameters:

waitTime - the maximum time to aquire the lock

leaseTime -

unit -

Returns:

Throws:

InterruptedException

lock

void 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

forceUnlock

void forceUnlock()

Unlocks lock independently of state

isLocked

boolean isLocked()

Checks if this lock locked by any thread

Returns:

true if locked otherwise false

isHeldByCurrentThread

boolean isHeldByCurrentThread()

Checks if this lock is held by the current thread

Returns:

@return true if held by current thread otherwise false

getHoldCount

int getHoldCount()

Number of holds on this lock by the current thread

Returns:

holds or 0 if this lock is not held by current thread

forceUnlockAsync

io.netty.util.concurrent.Future<Boolean> forceUnlockAsync()

unlockAsync

io.netty.util.concurrent.Future<Void> unlockAsync()

tryLockAsync

io.netty.util.concurrent.Future<Boolean> tryLockAsync()

lockAsync

io.netty.util.concurrent.Future<Void> lockAsync()

lockAsync

io.netty.util.concurrent.Future<Void> lockAsync(long leaseTime,
                                              TimeUnit unit)

tryLockAsync

io.netty.util.concurrent.Future<Boolean> tryLockAsync(long waitTime,
                                                    TimeUnit unit)

tryLockAsync

io.netty.util.concurrent.Future<Boolean> tryLockAsync(long waitTime,
                                                    long leaseTime,
                                                    TimeUnit unit)