RedissonCountDownLatch (Redisson 2.2.26 API)

java.lang.Object
- org.redisson.RedissonCountDownLatch

All Implemented Interfaces:

RCountDownLatch, RCountDownLatchAsync, RObject, RObjectAsync
```
public class RedissonCountDownLatch
extends Object
implements RCountDownLatch
```
Distributed alternative to the CountDownLatch It has a advantage over CountDownLatch -- count can be reset via trySetCount(long).

Author:

Nikita Koksharov

Field Summary

Fields
Modifier and Type Field and Description

static Long newCountMessage

static Long zeroCountMessage

Fields
Modifier and Type	Field and Description
`static Long`	`newCountMessage`
`static Long`	`zeroCountMessage`

Constructor Summary

Constructors
Modifier Constructor and Description

protected RedissonCountDownLatch(CommandAsyncExecutor commandExecutor, String name, UUID id)

Constructors
Modifier	Constructor and Description
`protected`	`RedissonCountDownLatch(CommandAsyncExecutor commandExecutor, String name, UUID id)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`await()` Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted.
`protected boolean`	`await(io.netty.util.concurrent.Future<?> future, long timeout, TimeUnit timeoutUnit)`
`boolean`	`await(long time, TimeUnit unit)` Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted, or the specified waiting time elapses.
`void`	`countDown()` Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
`io.netty.util.concurrent.Future<Void>`	`countDownAsync()` Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
`boolean`	`delete()` Deletes the object
`io.netty.util.concurrent.Future<Boolean>`	`deleteAsync()` Delete object in async mode
`protected <V> V`	`get(io.netty.util.concurrent.Future<V> future)`
`long`	`getCount()` Returns the current count.
`io.netty.util.concurrent.Future<Long>`	`getCountAsync()` Returns the current count.
`String`	`getName()` Returns name of object
`boolean`	`isExists()` Check object existence
`io.netty.util.concurrent.Future<Boolean>`	`isExistsAsync()` Check object existence in async mode.
`void`	`migrate(String host, int port, int database)` Transfer an object from source Redis instance to destination Redis instance
`io.netty.util.concurrent.Future<Void>`	`migrateAsync(String host, int port, int database)` Transfer an object from source Redis instance to destination Redis instance in async mode
`boolean`	`move(int database)` Move object to another database
`io.netty.util.concurrent.Future<Boolean>`	`moveAsync(int database)` Move object to another database in async mode
`protected <V> io.netty.util.concurrent.Promise<V>`	`newPromise()`
`protected <V> io.netty.util.concurrent.Future<V>`	`newSucceededFuture(V result)`
`void`	`rename(String newName)` Rename current object key to `newName`
`io.netty.util.concurrent.Future<Void>`	`renameAsync(String newName)` Rename current object key to `newName` in async mode
`boolean`	`renamenx(String newName)` Rename current object key to `newName` only if new key is not exists
`io.netty.util.concurrent.Future<Boolean>`	`renamenxAsync(String newName)` Rename current object key to `newName` in async mode only if new key is not exists
`boolean`	`trySetCount(long count)` Sets new count value only if previous count already has reached zero or is not set at all.
`io.netty.util.concurrent.Future<Boolean>`	`trySetCountAsync(long count)` Sets new count value only if previous count already has reached zero or is not set at all.

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

Methods inherited from interface org.redisson.core.RObject
delete, getName, isExists, migrate, move, rename, renamenx

Methods inherited from interface org.redisson.core.RObjectAsync
isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync

- Field Detail
  - zeroCountMessage
```
public static final Long zeroCountMessage
```
  - newCountMessage
```
public static final Long newCountMessage
```
- Constructor Detail
  - RedissonCountDownLatch
```
protected RedissonCountDownLatch(CommandAsyncExecutor commandExecutor,
                      String name,
                      UUID id)
```
- Method Detail
  - await
```
public void await()
           throws InterruptedException
```
    Description copied from interface: RCountDownLatch
    Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted.
    If the current count is zero then this method returns immediately.
    If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happen:
    - The count reaches zero due to invocations of the RCountDownLatch.countDown() method; or
    - Some other thread interrupts the current thread.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    Specified by:
    
    await in interface RCountDownLatch
    
    Throws:
    
    InterruptedException - if the current thread is interrupted while waiting
  - await
```
public boolean await(long time,
            TimeUnit unit)
              throws InterruptedException
```
    Description copied from interface: RCountDownLatch
    Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted, or the specified waiting time elapses.
    If the current count is zero then this method returns immediately with the value true.
    If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happen:
    - The count reaches zero due to invocations of the RCountDownLatch.countDown() method; or
    - Some other thread interrupts the current thread; or
    - The specified waiting time elapses.
    If the count reaches zero then the method returns with the value true.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    If the specified waiting time elapses then the value false is returned. If the time is less than or equal to zero, the method will not wait at all.
    Specified by:
    
    await in interface RCountDownLatch
    
    Parameters:
    time - the maximum time to wait
    unit - the time unit of the timeout argument
    
    Returns:
    true if the count reached zero and false if the waiting time elapsed before the count reached zero
    
    Throws:
    
    InterruptedException - if the current thread is interrupted while waiting
  - countDown
```
public void countDown()
```
    Description copied from interface: RCountDownLatch
    
    Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
    If the current count is greater than zero then it is decremented. If the new count is zero then all waiting threads are re-enabled for thread scheduling purposes.
    If the current count equals zero then nothing happens.
    
    Specified by:
    
    countDown in interface RCountDownLatch
  - countDownAsync
```
public io.netty.util.concurrent.Future<Void> countDownAsync()
```
    Description copied from interface: RCountDownLatchAsync
    
    Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
    If the current count is greater than zero then it is decremented. If the new count is zero then all waiting threads are re-enabled for thread scheduling purposes.
    If the current count equals zero then nothing happens.
    
    Specified by:
    
    countDownAsync in interface RCountDownLatchAsync
  - getCount
```
public long getCount()
```
    Description copied from interface: RCountDownLatch
    
    Returns the current count.
    This method is typically used for debugging and testing purposes.
    
    Specified by:
    
    getCount in interface RCountDownLatch
    
    Returns:
    the current count
  - getCountAsync
```
public io.netty.util.concurrent.Future<Long> getCountAsync()
```
    Description copied from interface: RCountDownLatchAsync
    
    Returns the current count.
    This method is typically used for debugging and testing purposes.
    
    Specified by:
    
    getCountAsync in interface RCountDownLatchAsync
    
    Returns:
    the current count
  - trySetCount
```
public boolean trySetCount(long count)
```
    Description copied from interface: RCountDownLatch
    
    Sets new count value only if previous count already has reached zero or is not set at all.
    
    Specified by:
    
    trySetCount in interface RCountDownLatch
    
    Parameters:
    count - - number of times RCountDownLatch.countDown() must be invoked before threads can pass through RCountDownLatch.await()
    
    Returns:
    true if new count setted false if previous count has not reached zero
  - trySetCountAsync
```
public io.netty.util.concurrent.Future<Boolean> trySetCountAsync(long count)
```
    Description copied from interface: RCountDownLatchAsync
    
    Sets new count value only if previous count already has reached zero or is not set at all.
    
    Specified by:
    
    trySetCountAsync in interface RCountDownLatchAsync
    
    Parameters:
    count - - number of times #countDown must be invoked before threads can pass through #await
    
    Returns:
    true if new count setted false if previous count has not reached zero
  - deleteAsync
```
public io.netty.util.concurrent.Future<Boolean> deleteAsync()
```
    Description copied from interface: RObjectAsync
    
    Delete object in async mode
    
    Specified by:
    
    deleteAsync in interface RObjectAsync
    
    Returns:
    true if object was deleted false if not
  - await
```
protected boolean await(io.netty.util.concurrent.Future<?> future,
            long timeout,
            TimeUnit timeoutUnit)
                 throws InterruptedException
```
    Throws:
    
    InterruptedException
  - get
```
protected <V> V get(io.netty.util.concurrent.Future<V> future)
```
  - newPromise
```
protected <V> io.netty.util.concurrent.Promise<V> newPromise()
```
  - newSucceededFuture
```
protected <V> io.netty.util.concurrent.Future<V> newSucceededFuture(V result)
```
  - getName
```
public String getName()
```
    Description copied from interface: RObject
    
    Returns name of object
    
    Specified by:
    
    getName in interface RObject
    
    Returns:
    name
  - rename
```
public void rename(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName
    
    Specified by:
    
    rename in interface RObject
  - renameAsync
```
public io.netty.util.concurrent.Future<Void> renameAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode
    
    Specified by:
    
    renameAsync in interface RObjectAsync
    
    Returns:
  - migrate
```
public void migrate(String host,
           int port,
           int database)
```
    Description copied from interface: RObject
    
    Transfer an object from source Redis instance to destination Redis instance
    
    Specified by:
    
    migrate in interface RObject
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
  - migrateAsync
```
public io.netty.util.concurrent.Future<Void> migrateAsync(String host,
                                                 int port,
                                                 int database)
```
    Description copied from interface: RObjectAsync
    
    Transfer an object from source Redis instance to destination Redis instance in async mode
    
    Specified by:
    
    migrateAsync in interface RObjectAsync
    
    Parameters:
    host - - destination host
    port - - destination port
    database - - destination database
    
    Returns:
  - move
```
public boolean move(int database)
```
    Description copied from interface: RObject
    
    Move object to another database
    
    Specified by:
    
    move in interface RObject
    
    Returns:
    true if key was moved else false
  - moveAsync
```
public io.netty.util.concurrent.Future<Boolean> moveAsync(int database)
```
    Description copied from interface: RObjectAsync
    
    Move object to another database in async mode
    
    Specified by:
    
    moveAsync in interface RObjectAsync
    
    Returns:
    true if key was moved false if not
  - renamenx
```
public boolean renamenx(String newName)
```
    Description copied from interface: RObject
    
    Rename current object key to newName only if new key is not exists
    
    Specified by:
    
    renamenx in interface RObject
    
    Returns:
  - renamenxAsync
```
public io.netty.util.concurrent.Future<Boolean> renamenxAsync(String newName)
```
    Description copied from interface: RObjectAsync
    
    Rename current object key to newName in async mode only if new key is not exists
    
    Specified by:
    
    renamenxAsync in interface RObjectAsync
    
    Returns:
  - delete
```
public boolean delete()
```
    Description copied from interface: RObject
    
    Deletes the object
    
    Specified by:
    
    delete in interface RObject
  - isExists
```
public boolean isExists()
```
    Description copied from interface: RObject
    
    Check object existence
    
    Specified by:
    
    isExists in interface RObject
    
    Returns:
    true if object exists and false otherwise
  - isExistsAsync
```
public io.netty.util.concurrent.Future<Boolean> isExistsAsync()
```
    Description copied from interface: RObjectAsync
    
    Check object existence in async mode.
    
    Specified by:
    
    isExistsAsync in interface RObjectAsync
    
    Returns:
    true if object exists and false otherwise

Class RedissonCountDownLatch

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.redisson.core.RObject

Methods inherited from interface org.redisson.core.RObjectAsync

Field Detail

zeroCountMessage

newCountMessage

Constructor Detail

RedissonCountDownLatch

Method Detail

await

await

countDown

countDownAsync

getCount

getCountAsync

trySetCount

trySetCountAsync

deleteAsync

await

get

newPromise

newSucceededFuture

getName

rename

renameAsync

migrate

migrateAsync

move

moveAsync

renamenx

renamenxAsync

delete

isExists

isExistsAsync