Package org.redisson

Class RedissonSpinLock

  • All Implemented Interfaces:
    Lock, RExpirable, RExpirableAsync, RLock, RLockAsync, RObject, RObjectAsync

    public class RedissonSpinLock
    extends RedissonBaseLock
    Distributed implementation of Lock Implements reentrant lock.
    Lock will be removed automatically if client disconnects. This lock implementation doesn't use pub/sub mechanism. It can be used in large Redis clusters despite current naive pub/sub implementation.

    Implements a non-fair locking so doesn't guarantees an acquire order.

    Author:
    Danila Varatyntsev
    • Field Detail

      • internalLockLeaseTime

        protected long internalLockLeaseTime
    • Method Detail

      • lock

        public void 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.
        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
      • 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.
        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()
      • 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.
        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
      • unlock

        public void unlock()
      • forceUnlock

        public boolean forceUnlock()
        Description copied from interface: RLock
        Unlocks the lock independently of its state
        Returns:
        true if lock existed and now unlocked otherwise false
      • forceUnlockAsync

        public RFuture<Boolean> forceUnlockAsync()
        Description copied from interface: RLockAsync
        Unlocks the lock independently of its state
        Returns:
        true if lock existed and now unlocked otherwise false
      • lockAsync

        public RFuture<Void> lockAsync()
        Description copied from interface: RLockAsync
        Acquires the lock. Waits if necessary until lock became available.
        Returns:
        void
      • 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.
        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 currentThreadId)
        Description copied from interface: RLockAsync
        Acquires the lock by thread with defined threadId. Waits if necessary until lock became available.
        Parameters:
        currentThreadId - id of thread
        Returns:
        void
      • lockAsync

        public RFuture<Void> lockAsync​(long leaseTime,
                                       TimeUnit unit,
                                       long currentThreadId)
        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.
        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
        currentThreadId - id of thread
        Returns:
        void
      • tryLockAsync

        public RFuture<Boolean> tryLockAsync()
        Description copied from interface: RLockAsync
        Tries to acquire the lock.
        Returns:
        true if lock acquired otherwise false
      • tryLockAsync

        public RFuture<Boolean> tryLockAsync​(long threadId)
        Description copied from interface: RLockAsync
        Tries to acquire the lock by thread with specified threadId.
        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.
        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.
      • 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.
        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.
      • tryLockAsync

        public RFuture<Boolean> tryLockAsync​(long waitTime,
                                             long leaseTime,
                                             TimeUnit unit,
                                             long currentThreadId)
        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.
        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
        currentThreadId - id of thread
        Returns:
        true if lock acquired otherwise false
      • expire

        public boolean expire​(long timeToLive,
                              TimeUnit timeUnit)
        Description copied from interface: RExpirable
        Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
        Specified by:
        expire in interface RExpirable
        Parameters:
        timeToLive - - timeout before object will be deleted
        timeUnit - - timeout time unit
        Returns:
        true if the timeout was set and false if not
      • expireAsync

        public RFuture<Boolean> expireAsync​(long timeToLive,
                                            TimeUnit timeUnit)
        Description copied from interface: RExpirableAsync
        Set a timeout for object in async mode. After the timeout has expired, the key will automatically be deleted.
        Specified by:
        expireAsync in interface RExpirableAsync
        Parameters:
        timeToLive - - timeout before object will be deleted
        timeUnit - - timeout time unit
        Returns:
        true if the timeout was set and false if not
      • expireAt

        public boolean expireAt​(long timestamp)
        Description copied from interface: RExpirable
        Specified by:
        expireAt in interface RExpirable
        Parameters:
        timestamp - - expire date in milliseconds (Unix timestamp)
        Returns:
        true if the timeout was set and false if not
      • expire

        public boolean expire​(Instant instant)
        Description copied from interface: RExpirable
        Set an expire date for object. When expire date comes the key will automatically be deleted.
        Specified by:
        expire in interface RExpirable
        Parameters:
        instant - - expire date
        Returns:
        true if the timeout was set and false if not
      • expireAsync

        public RFuture<Boolean> expireAsync​(Instant instant)
        Description copied from interface: RExpirableAsync
        Set an expire date for object. When expire date comes the key will automatically be deleted.
        Specified by:
        expireAsync in interface RExpirableAsync
        Parameters:
        instant - - expire date
        Returns:
        true if the timeout was set and false if not
      • clearExpire

        public boolean clearExpire()
        Description copied from interface: RExpirable
        Clear an expire timeout or expire date for object.
        Specified by:
        clearExpire in interface RExpirable
        Returns:
        true if timeout was removed false if object does not exist or does not have an associated timeout
      • clearExpireAsync

        public RFuture<Boolean> clearExpireAsync()
        Description copied from interface: RExpirableAsync
        Clear an expire timeout or expire date for object in async mode. Object will not be deleted.
        Specified by:
        clearExpireAsync in interface RExpirableAsync
        Returns:
        true if the timeout was cleared and false if not
      • remainTimeToLive

        public long remainTimeToLive()
        Description copied from interface: RExpirable
        Remaining time to live of Redisson object that has a timeout
        Specified by:
        remainTimeToLive in interface RExpirable
        Returns:
        time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
      • remainTimeToLiveAsync

        public RFuture<Long> remainTimeToLiveAsync()
        Description copied from interface: RExpirableAsync
        Remaining time to live of Redisson object that has a timeout
        Specified by:
        remainTimeToLiveAsync in interface RExpirableAsync
        Returns:
        time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.