java.lang.Object
- org.redisson.RedissonObject
- - org.redisson.RedissonTransferQueue<V>

All Implemented Interfaces:

Iterable<V>, Collection<V>, BlockingQueue<V>, TransferQueue<V>, Queue<V>, RBlockingQueue<V>, RBlockingQueueAsync<V>, RCollectionAsync<V>, RExpirable, RExpirableAsync, RObject, RObjectAsync, RQueue<V>, RQueueAsync<V>, RTransferQueue<V>, RTransferQueueAsync<V>
```
public class RedissonTransferQueue<V>
extends RedissonObject
implements RTransferQueue<V>
```
Author:

Nikita Koksharov

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static interface`	`RedissonTransferQueue.TransferQueueService`
`static interface`	`RedissonTransferQueue.TransferQueueServiceAsync`
`static class`	`RedissonTransferQueue.TransferQueueServiceImpl`

Field Summary
- Fields inherited from class org.redisson.RedissonObject
  codec, commandExecutor, name

Constructor Summary

Constructors
Constructor	Description
`RedissonTransferQueue(Codec codec, CommandAsyncExecutor commandExecutor, String name, RRemoteService remoteService)`
`RedissonTransferQueue(CommandAsyncExecutor commandExecutor, String name, RRemoteService remoteService)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`add(V v)`
`boolean`	`addAll(Collection<? extends V> c)`
`RFuture<Boolean>`	`addAllAsync(Collection<? extends V> c)`	Adds all elements contained in the specified collection
`RFuture<Boolean>`	`addAsync(V v)`	Adds element into this collection.
`void`	`clear()`
`RFuture<Void>`	`clearAsync()`
`boolean`	`clearExpire()`	Clear an expire timeout or expire date for object.
`RFuture<Boolean>`	`clearExpireAsync()`	Clear an expire timeout or expire date for object in async mode.
`protected RFuture<Boolean>`	`clearExpireAsync(String... keys)`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`RFuture<Boolean>`	`containsAllAsync(Collection<?> c)`	Returns `true` if this collection contains all of the elements in the specified collection.
`RFuture<Boolean>`	`containsAsync(Object o)`	Returns `true` if this collection contains encoded state of the specified element.
`int`	`drainTo(Collection<? super V> c)`
`int`	`drainTo(Collection<? super V> c, int maxElements)`
`RFuture<Integer>`	`drainToAsync(Collection<? super V> c)`	Removes all available elements from this queue and adds them to the given collection in async mode.
`RFuture<Integer>`	`drainToAsync(Collection<? super V> c, int maxElements)`	Removes at most the given number of available elements from this queue and adds them to the given collection in async mode.
`V`	`element()`
`boolean`	`expire(long timeToLive, TimeUnit timeUnit)`	Use `RExpirable.expire(Duration)` instead
`boolean`	`expire(Duration duration)`	Sets a timeout for this object.
`boolean`	`expire(Instant instant)`	Sets an expiration date for this object.
`RFuture<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit)`	Use `RExpirableAsync.expireAsync(Duration)` instead
`protected RFuture<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)`
`RFuture<Boolean>`	`expireAsync(Duration duration)`	Set a timeout for object.
`RFuture<Boolean>`	`expireAsync(Instant instant)`	Set an expire date for object.
`boolean`	`expireAt(long timestamp)`	Use `RExpirable.expire(Instant)` instead
`boolean`	`expireAt(Date timestamp)`	Use `RExpirable.expire(Instant)` instead
`RFuture<Boolean>`	`expireAtAsync(long timestamp)`	Use `RExpirableAsync.expireAsync(Instant)` instead
`protected RFuture<Boolean>`	`expireAtAsync(long timestamp, String param, String... keys)`
`RFuture<Boolean>`	`expireAtAsync(Date timestamp)`	Use `RExpirableAsync.expireAsync(Instant)` instead
`boolean`	`expireIfGreater(Duration duration)`	Sets a timeout for this object only if it's greater than timeout set before.
`boolean`	`expireIfGreater(Instant time)`	Sets an expiration date for this object only if it's greater than expiration date set before.
`RFuture<Boolean>`	`expireIfGreaterAsync(Duration duration)`
`RFuture<Boolean>`	`expireIfGreaterAsync(Instant time)`
`boolean`	`expireIfLess(Duration duration)`	Sets a timeout for this object only if it's less than timeout set before.
`boolean`	`expireIfLess(Instant time)`	Sets an expiration date for this object only if it's less than expiration date set before.
`RFuture<Boolean>`	`expireIfLessAsync(Duration duration)`
`RFuture<Boolean>`	`expireIfLessAsync(Instant time)`
`boolean`	`expireIfNotSet(Duration duration)`	Sets a timeout for this object only if it hasn't been set before.
`boolean`	`expireIfNotSet(Instant time)`	Sets an expiration date for this object only if it hasn't been set before.
`RFuture<Boolean>`	`expireIfNotSetAsync(Duration duration)`
`RFuture<Boolean>`	`expireIfNotSetAsync(Instant time)`
`boolean`	`expireIfSet(Duration duration)`	Sets a timeout for this object only if it has been already set.
`boolean`	`expireIfSet(Instant time)`	Sets an expiration date for this object only if it has been already set.
`RFuture<Boolean>`	`expireIfSetAsync(Duration duration)`
`RFuture<Boolean>`	`expireIfSetAsync(Instant time)`
`long`	`getExpireTime()`	Expiration time of Redisson object that has a timeout
`RFuture<Long>`	`getExpireTimeAsync()`	Expiration time of Redisson object that has a timeout
`RFuture<V>`	`getValueAsync(int index)`
`int`	`getWaitingConsumerCount()`
`boolean`	`hasWaitingConsumer()`
`boolean`	`isEmpty()`
`Iterator<V>`	`iterator()`
`boolean`	`offer(V v)`
`boolean`	`offer(V v, long timeout, TimeUnit unit)`
`RFuture<Boolean>`	`offerAsync(V e)`	Inserts the specified element into this queue.
`V`	`peek()`
`RFuture<V>`	`peekAsync()`	Retrieves the head of this queue in async mode.
`V`	`poll()`
`List<V>`	`poll(int limit)`	Retrieves and removes the head elements of this queue.
`V`	`poll(long timeout, TimeUnit unit)`
`RFuture<V>`	`pollAsync()`	Retrieves and removes the head of this queue in async mode.
`RFuture<List<V>>`	`pollAsync(int limit)`	Retrieves and removes the head elements of this queue.
`RFuture<V>`	`pollAsync(long timeout, TimeUnit unit)`	Retrieves and removes the head of this queue in async mode, waiting up to the specified wait time if necessary for an element to become available.
`Map<String,List<V>>`	`pollFirstFromAny(Duration duration, int count, String... queueNames)`	Retrieves and removes first available head elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`RFuture<Map<String,List<V>>>`	`pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)`	Retrieves and removes first available head elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`V`	`pollFromAny(long timeout, TimeUnit unit, String... queueNames)`	Retrieves and removes first available head element of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`RFuture<V>`	`pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)`	Retrieves and removes first available head element of any queue in async mode, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`V`	`pollLastAndOfferFirstTo(String queueName)`	Retrieves and removes last available tail element of this queue queue and adds it at the head of `queueName`.
`V`	`pollLastAndOfferFirstTo(String queueName, long timeout, TimeUnit unit)`	Retrieves and removes last available tail element of this queue and adds it at the head of `queueName`, waiting up to the specified wait time if necessary for an element to become available.
`RFuture<V>`	`pollLastAndOfferFirstToAsync(String queueName)`	Retrieves and removes last available tail element of this queue queue and adds it at the head of `queueName`.
`RFuture<V>`	`pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)`	Retrieves and removes last available tail element of this queue and adds it at the head of `queueName`, waiting up to the specified wait time if necessary for an element to become available.
`Map<String,List<V>>`	`pollLastFromAny(Duration duration, int count, String... queueNames)`	Retrieves and removes first available tail elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`RFuture<Map<String,List<V>>>`	`pollLastFromAnyAsync(Duration duration, int count, String... queueNames)`	Retrieves and removes first available tail elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
`void`	`put(V v)`
`RFuture<Void>`	`putAsync(V value)`	Inserts the specified element into this queue in async mode, waiting if necessary for space to become available.
`List<V>`	`readAll()`	Returns all queue elements at once
`RFuture<List<V>>`	`readAllAsync()`	Returns all queue elements at once
`int`	`remainingCapacity()`
`long`	`remainTimeToLive()`	Remaining time to live of Redisson object that has a timeout
`RFuture<Long>`	`remainTimeToLiveAsync()`	Remaining time to live of Redisson object that has a timeout
`V`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`RFuture<Boolean>`	`removeAllAsync(Collection<?> c)`	Removes all of this collection's elements that are also contained in the specified collection.
`RFuture<Boolean>`	`removeAsync(Object o)`	Removes a single instance of the specified element from this collection, if it is present.
`boolean`	`retainAll(Collection<?> c)`
`RFuture<Boolean>`	`retainAllAsync(Collection<?> c)`	Retains only the elements in this collection that are contained in the specified collection.
`int`	`size()`
`RFuture<Integer>`	`sizeAsync()`	Returns number of elements in this collection.
`int`	`subscribeOnElements(Consumer<V> consumer)`	Subscribes on elements appeared in this queue.
`V`	`take()`
`RFuture<V>`	`takeAsync()`	Retrieves and removes the head of this queue in async mode, waiting if necessary until an element becomes available.
`V`	`takeLastAndOfferFirstTo(String queueName)`	Retrieves and removes last available tail element of any queue and adds it at the head of `queueName`, waiting if necessary for an element to become available in any of defined queues including queue itself.
`RFuture<V>`	`takeLastAndOfferFirstToAsync(String queueName)`	Retrieves and removes last available tail element of any queue and adds it at the head of `queueName`, waiting if necessary for an element to become available in any of defined queues including queue itself.
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`void`	`transfer(V v)`
`RFuture<Void>`	`transferAsync(V v)`	Transfers the element to waiting consumer which invoked `RBlockingQueueAsync.takeAsync()` or `RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit)` method at the moment of transfer.
`boolean`	`tryTransfer(V v)`
`boolean`	`tryTransfer(V v, long timeout, TimeUnit unit)`
`RFuture<Boolean>`	`tryTransferAsync(V v)`	Tries to transfer the element to waiting consumer which invoked `RBlockingQueueAsync.takeAsync()` or `RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit)` method at the moment of transfer.
`RFuture<Boolean>`	`tryTransferAsync(V v, long timeout, TimeUnit unit)`	Transfers the element to waiting consumer which invoked `RBlockingQueueAsync.takeAsync()` or `RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit)` method at the moment of transfer.
`void`	`unsubscribe(int listenerId)`	Un-subscribes defined listener.

Methods inherited from class org.redisson.RedissonObject
addListener, addListener, addListenerAsync, addListenerAsync, copy, copyAsync, delete, deleteAsync, deleteAsync, dump, dumpAsync, encode, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getIdleTime, getIdleTimeAsync, getLockByMapKey, getLockByValue, getName, getRawName, getRawName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, removeListener, removeListenerAsync, rename, renameAsync, renamenx, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, setName, sizeInMemory, sizeInMemoryAsync, sizeInMemoryAsync, sizeInMemoryAsync, suffixName, toSeconds, toStream, touch, touchAsync, unlink, unlinkAsync

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

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream, toArray

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface org.redisson.api.RExpirable
clearExpire, expire, expire, expire, expireAt, expireAt, expireIfGreater, expireIfGreater, expireIfLess, expireIfLess, expireIfNotSet, expireIfNotSet, expireIfSet, expireIfSet, getExpireTime, remainTimeToLive

Methods inherited from interface org.redisson.api.RExpirableAsync
clearExpireAsync, expireAsync, expireAsync, expireAsync, expireAtAsync, expireAtAsync, expireIfGreaterAsync, expireIfGreaterAsync, expireIfLessAsync, expireIfLessAsync, expireIfNotSetAsync, expireIfNotSetAsync, expireIfSetAsync, expireIfSetAsync, getExpireTimeAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObject
copy, delete, dump, getCodec, getIdleTime, getName, isExists, migrate, move, removeListener, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

Methods inherited from interface org.redisson.api.RObjectAsync
copyAsync, deleteAsync, dumpAsync, getIdleTimeAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsync

Methods inherited from interface org.redisson.api.RQueue
addListener

Methods inherited from interface org.redisson.api.RQueueAsync
addListenerAsync

- Constructor Detail
  - RedissonTransferQueue
```
public RedissonTransferQueue(Codec codec,
                             CommandAsyncExecutor commandExecutor,
                             String name,
                             RRemoteService remoteService)
```
  - RedissonTransferQueue
```
public RedissonTransferQueue(CommandAsyncExecutor commandExecutor,
                             String name,
                             RRemoteService remoteService)
```
- Method Detail
  - tryTransfer
```
public boolean tryTransfer(V v)
```
    Specified by:
    
    tryTransfer in interface TransferQueue<V>
  - tryTransferAsync
```
public RFuture<Boolean> tryTransferAsync(V v)
```
    Description copied from interface: RTransferQueueAsync
    
    Tries to transfer the element to waiting consumer which invoked RBlockingQueueAsync.takeAsync() or RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit) method at the moment of transfer.
    
    Specified by:
    
    tryTransferAsync in interface RTransferQueueAsync<V>
    
    Parameters:
    
    v - element to transfer
    
    Returns:
    
    true if element was transferred, otherwise false
  - transfer
```
public void transfer(V v)
              throws InterruptedException
```
    Specified by:
    
    transfer in interface TransferQueue<V>
    
    Throws:
    
    InterruptedException
  - transferAsync
```
public RFuture<Void> transferAsync(V v)
```
    Description copied from interface: RTransferQueueAsync
    
    Transfers the element to waiting consumer which invoked RBlockingQueueAsync.takeAsync() or RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit) method at the moment of transfer. Waits if necessary for a consumer.
    
    Specified by:
    
    transferAsync in interface RTransferQueueAsync<V>
    
    Parameters:
    
    v - the element to transfer
  - tryTransfer
```
public boolean tryTransfer(V v,
                           long timeout,
                           TimeUnit unit)
                    throws InterruptedException
```
    Specified by:
    
    tryTransfer in interface TransferQueue<V>
    
    Throws:
    
    InterruptedException
  - tryTransferAsync
```
public RFuture<Boolean> tryTransferAsync(V v,
                                         long timeout,
                                         TimeUnit unit)
```
    Description copied from interface: RTransferQueueAsync
    
    Transfers the element to waiting consumer which invoked RBlockingQueueAsync.takeAsync() or RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit) method at the moment of transfer. Waits up to defined timeout if necessary for a consumer.
    
    Specified by:
    
    tryTransferAsync in interface RTransferQueueAsync<V>
    
    Parameters:
    
    v - the element to transfer
    
    timeout - the maximum time to wait
    
    unit - the time unit
    
    Returns:
    
    true if the element was transferred and false otherwise
  - hasWaitingConsumer
```
public boolean hasWaitingConsumer()
```
    Specified by:
    
    hasWaitingConsumer in interface TransferQueue<V>
  - getWaitingConsumerCount
```
public int getWaitingConsumerCount()
```
    Specified by:
    
    getWaitingConsumerCount in interface TransferQueue<V>
  - add
```
public boolean add(V v)
```
    Specified by:
    
    add in interface BlockingQueue<V>
    
    Specified by:
    
    add in interface Collection<V>
    
    Specified by:
    
    add in interface Queue<V>
  - addAsync
```
public RFuture<Boolean> addAsync(V v)
```
    Description copied from interface: RCollectionAsync
    
    Adds element into this collection.
    
    Specified by:
    
    addAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    v - - element to add
    
    Returns:
    
    true if an element was added and false if it is already present
  - offer
```
public boolean offer(V v)
```
    Specified by:
    
    offer in interface BlockingQueue<V>
    
    Specified by:
    
    offer in interface Queue<V>
  - remove
```
public V remove()
```
    Specified by:
    
    remove in interface Queue<V>
  - poll
```
public V poll()
```
    Specified by:
    
    poll in interface Queue<V>
  - pollAsync
```
public RFuture<V> pollAsync()
```
    Description copied from interface: RQueueAsync
    
    Retrieves and removes the head of this queue in async mode.
    
    Specified by:
    
    pollAsync in interface RQueueAsync<V>
    
    Returns:
    
    the head of this queue, or null
  - element
```
public V element()
```
    Specified by:
    
    element in interface Queue<V>
  - peek
```
public V peek()
```
    Specified by:
    
    peek in interface Queue<V>
  - peekAsync
```
public RFuture<V> peekAsync()
```
    Description copied from interface: RQueueAsync
    
    Retrieves the head of this queue in async mode.
    
    Specified by:
    
    peekAsync in interface RQueueAsync<V>
    
    Returns:
    
    the head of this queue, or null
  - put
```
public void put(V v)
         throws InterruptedException
```
    Specified by:
    
    put in interface BlockingQueue<V>
    
    Throws:
    
    InterruptedException
  - offer
```
public boolean offer(V v,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
```
    Specified by:
    
    offer in interface BlockingQueue<V>
    
    Throws:
    
    InterruptedException
  - take
```
public V take()
       throws InterruptedException
```
    Specified by:
    
    take in interface BlockingQueue<V>
    
    Throws:
    
    InterruptedException
  - takeAsync
```
public RFuture<V> takeAsync()
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes the head of this queue in async mode, waiting if necessary until an element becomes available.
    
    Specified by:
    
    takeAsync in interface RBlockingQueueAsync<V>
    
    Returns:
    
    the head of this queue
  - poll
```
public V poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
```
    Specified by:
    
    poll in interface BlockingQueue<V>
    
    Throws:
    
    InterruptedException
  - pollAsync
```
public RFuture<V> pollAsync(long timeout,
                            TimeUnit unit)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes the head of this queue in async mode, waiting up to the specified wait time if necessary for an element to become available.
    
    Specified by:
    
    pollAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the head of this queue, or null if the specified waiting time elapses before an element is available
  - remainingCapacity
```
public int remainingCapacity()
```
    Specified by:
    
    remainingCapacity in interface BlockingQueue<V>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface BlockingQueue<V>
    
    Specified by:
    
    remove in interface Collection<V>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<V>
  - addAll
```
public boolean addAll(Collection<? extends V> c)
```
    Specified by:
    
    addAll in interface Collection<V>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<V>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<V>
  - clearAsync
```
public RFuture<Void> clearAsync()
```
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<V>
  - sizeAsync
```
public RFuture<Integer> sizeAsync()
```
    Description copied from interface: RCollectionAsync
    
    Returns number of elements in this collection.
    
    Specified by:
    
    sizeAsync in interface RCollectionAsync<V>
    
    Returns:
    
    size of collection
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<V>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface BlockingQueue<V>
    
    Specified by:
    
    contains in interface Collection<V>
  - getValueAsync
```
public RFuture<V> getValueAsync(int index)
```
  - iterator
```
public Iterator<V> iterator()
```
    Specified by:
    
    iterator in interface Collection<V>
    
    Specified by:
    
    iterator in interface Iterable<V>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<V>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<V>
  - drainTo
```
public int drainTo(Collection<? super V> c)
```
    Specified by:
    
    drainTo in interface BlockingQueue<V>
  - drainToAsync
```
public RFuture<Integer> drainToAsync(Collection<? super V> c)
```
    Description copied from interface: RBlockingQueueAsync
    
    Removes all available elements from this queue and adds them to the given collection in async mode. This operation may be more efficient than repeatedly polling this queue. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain a queue to itself result in IllegalArgumentException. Further, the behavior of this operation is undefined if the specified collection is modified while the operation is in progress.
    
    Specified by:
    
    drainToAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    c - the collection to transfer elements into
    
    Returns:
    
    the number of elements transferred
  - drainTo
```
public int drainTo(Collection<? super V> c,
                   int maxElements)
```
    Specified by:
    
    drainTo in interface BlockingQueue<V>
  - drainToAsync
```
public RFuture<Integer> drainToAsync(Collection<? super V> c,
                                     int maxElements)
```
    Description copied from interface: RBlockingQueueAsync
    
    Removes at most the given number of available elements from this queue and adds them to the given collection in async mode. A failure encountered while attempting to add elements to collection c may result in elements being in neither, either or both collections when the associated exception is thrown. Attempts to drain a queue to itself result in IllegalArgumentException. Further, the behavior of this operation is undefined if the specified collection is modified while the operation is in progress.
    
    Specified by:
    
    drainToAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    c - the collection to transfer elements into
    
    maxElements - the maximum number of elements to transfer
    
    Returns:
    
    the number of elements transferred
  - readAll
```
public List<V> readAll()
```
    Description copied from interface: RTransferQueue
    
    Returns all queue elements at once
    
    Specified by:
    
    readAll in interface RQueue<V>
    
    Specified by:
    
    readAll in interface RTransferQueue<V>
    
    Specified by:
    
    readAll in interface RTransferQueueAsync<V>
    
    Returns:
    
    elements
  - readAllAsync
```
public RFuture<List<V>> readAllAsync()
```
    Description copied from interface: RQueueAsync
    
    Returns all queue elements at once
    
    Specified by:
    
    readAllAsync in interface RQueueAsync<V>
    
    Returns:
    
    elements
  - pollFromAny
```
public V pollFromAny(long timeout,
                     TimeUnit unit,
                     String... queueNames)
              throws InterruptedException
```
    Description copied from interface: RBlockingQueue
    
    Retrieves and removes first available head element of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    
    Specified by:
    
    pollFromAny in interface RBlockingQueue<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - queue names. Queue name itself is always included
    
    Returns:
    
    the head of this queue, or null if the specified waiting time elapses before an element is available
    
    Throws:
    
    InterruptedException - if interrupted while waiting
  - pollFirstFromAny
```
public Map<String,List<V>> pollFirstFromAny(Duration duration,
                                                  int count,
                                                  String... queueNames)
                                           throws InterruptedException
```
    Description copied from interface: RBlockingQueue
    
    Retrieves and removes first available head elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    pollFirstFromAny in interface RBlockingQueue<V>
    
    Parameters:
    
    duration - how long to wait before giving up
    
    count - elements amount
    
    queueNames - name of queues
    
    Returns:
    
    the head elements
    
    Throws:
    
    InterruptedException
  - pollLastFromAny
```
public Map<String,List<V>> pollLastFromAny(Duration duration,
                                                 int count,
                                                 String... queueNames)
                                          throws InterruptedException
```
    Description copied from interface: RBlockingQueue
    
    Retrieves and removes first available tail elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    pollLastFromAny in interface RBlockingQueue<V>
    
    Parameters:
    
    duration - how long to wait before giving up
    
    count - elements amount
    
    queueNames - name of queues
    
    Returns:
    
    the tail elements
    
    Throws:
    
    InterruptedException
  - pollFirstFromAnyAsync
```
public RFuture<Map<String,List<V>>> pollFirstFromAnyAsync(Duration duration,
                                                                int count,
                                                                String... queueNames)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes first available head elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    pollFirstFromAnyAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    duration - how long to wait before giving up
    
    count - elements amount
    
    queueNames - name of queues
    
    Returns:
    
    the head elements
  - pollLastFromAnyAsync
```
public RFuture<Map<String,List<V>>> pollLastFromAnyAsync(Duration duration,
                                                               int count,
                                                               String... queueNames)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes first available tail elements of any queue, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    pollLastFromAnyAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    duration - how long to wait before giving up
    
    count - elements amount
    
    queueNames - name of queues
    
    Returns:
    
    the tail elements
  - pollLastAndOfferFirstTo
```
public V pollLastAndOfferFirstTo(String queueName,
                                 long timeout,
                                 TimeUnit unit)
                          throws InterruptedException
```
    Description copied from interface: RBlockingQueue
    
    Retrieves and removes last available tail element of this queue and adds it at the head of queueName, waiting up to the specified wait time if necessary for an element to become available.
    
    Specified by:
    
    pollLastAndOfferFirstTo in interface RBlockingQueue<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
    
    Throws:
    
    InterruptedException - if interrupted while waiting
  - takeLastAndOfferFirstTo
```
public V takeLastAndOfferFirstTo(String queueName)
                          throws InterruptedException
```
    Description copied from interface: RBlockingQueue
    
    Retrieves and removes last available tail element of any queue and adds it at the head of queueName, waiting if necessary for an element to become available in any of defined queues including queue itself.
    
    Specified by:
    
    takeLastAndOfferFirstTo in interface RBlockingQueue<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
    
    Throws:
    
    InterruptedException - if interrupted while waiting
  - subscribeOnElements
```
public int subscribeOnElements(Consumer<V> consumer)
```
    Description copied from interface: RBlockingQueue
    
    Subscribes on elements appeared in this queue. Continuously invokes RBlockingQueueAsync.takeAsync() method to get a new element.
    
    Specified by:
    
    subscribeOnElements in interface RBlockingQueue<V>
    
    Parameters:
    
    consumer - - queue elements listener
    
    Returns:
    
    listenerId - id of listener
  - unsubscribe
```
public void unsubscribe(int listenerId)
```
    Description copied from interface: RBlockingQueue
    
    Un-subscribes defined listener.
    
    Specified by:
    
    unsubscribe in interface RBlockingQueue<V>
    
    Parameters:
    
    listenerId - - id of listener
  - pollLastAndOfferFirstTo
```
public V pollLastAndOfferFirstTo(String queueName)
```
    Description copied from interface: RQueue
    
    Retrieves and removes last available tail element of this queue queue and adds it at the head of queueName.
    
    Specified by:
    
    pollLastAndOfferFirstTo in interface RQueue<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
  - poll
```
public List<V> poll(int limit)
```
    Description copied from interface: RQueue
    
    Retrieves and removes the head elements of this queue. Elements amount limited by limit param.
    
    Specified by:
    
    poll in interface RQueue<V>
    
    Returns:
    
    list of head elements
  - pollFromAnyAsync
```
public RFuture<V> pollFromAnyAsync(long timeout,
                                   TimeUnit unit,
                                   String... queueNames)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes first available head element of any queue in async mode, waiting up to the specified wait time if necessary for an element to become available in any of defined queues including queue itself.
    
    Specified by:
    
    pollFromAnyAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    queueNames - - queue names. Queue name itself is always included
    
    Returns:
    
    Future object with the head of this queue, or null if the specified waiting time elapses before an element is available
  - pollLastAndOfferFirstToAsync
```
public RFuture<V> pollLastAndOfferFirstToAsync(String queueName,
                                               long timeout,
                                               TimeUnit unit)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes last available tail element of this queue and adds it at the head of queueName, waiting up to the specified wait time if necessary for an element to become available.
    
    Specified by:
    
    pollLastAndOfferFirstToAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    timeout - how long to wait before giving up, in units of unit
    
    unit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
  - takeLastAndOfferFirstToAsync
```
public RFuture<V> takeLastAndOfferFirstToAsync(String queueName)
```
    Description copied from interface: RBlockingQueueAsync
    
    Retrieves and removes last available tail element of any queue and adds it at the head of queueName, waiting if necessary for an element to become available in any of defined queues including queue itself.
    
    Specified by:
    
    takeLastAndOfferFirstToAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
  - putAsync
```
public RFuture<Void> putAsync(V value)
```
    Description copied from interface: RBlockingQueueAsync
    
    Inserts the specified element into this queue in async mode, waiting if necessary for space to become available.
    
    Specified by:
    
    putAsync in interface RBlockingQueueAsync<V>
    
    Parameters:
    
    value - the element to add
    
    Returns:
    
    void
  - offerAsync
```
public RFuture<Boolean> offerAsync(V e)
```
    Description copied from interface: RQueueAsync
    
    Inserts the specified element into this queue.
    
    Specified by:
    
    offerAsync in interface RQueueAsync<V>
    
    Parameters:
    
    e - the element to add
    
    Returns:
    
    true if successful, or false
  - pollLastAndOfferFirstToAsync
```
public RFuture<V> pollLastAndOfferFirstToAsync(String queueName)
```
    Description copied from interface: RQueueAsync
    
    Retrieves and removes last available tail element of this queue queue and adds it at the head of queueName.
    
    Specified by:
    
    pollLastAndOfferFirstToAsync in interface RQueueAsync<V>
    
    Parameters:
    
    queueName - - names of destination queue
    
    Returns:
    
    the tail of this queue, or null if the specified waiting time elapses before an element is available
  - pollAsync
```
public RFuture<List<V>> pollAsync(int limit)
```
    Description copied from interface: RQueueAsync
    
    Retrieves and removes the head elements of this queue. Elements amount limited by limit param.
    
    Specified by:
    
    pollAsync in interface RQueueAsync<V>
    
    Returns:
    
    list of head elements
  - retainAllAsync
```
public RFuture<Boolean> retainAllAsync(Collection<?> c)
```
    Description copied from interface: RCollectionAsync
    
    Retains only the elements in this collection that are contained in the specified collection.
    
    Specified by:
    
    retainAllAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    c - collection containing elements to be retained in this collection
    
    Returns:
    
    true if this collection changed as a result of the call
  - removeAllAsync
```
public RFuture<Boolean> removeAllAsync(Collection<?> c)
```
    Description copied from interface: RCollectionAsync
    
    Removes all of this collection's elements that are also contained in the specified collection.
    
    Specified by:
    
    removeAllAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    c - collection containing elements to be removed from this collection
    
    Returns:
    
    true if this collection changed as a result of the call
  - containsAsync
```
public RFuture<Boolean> containsAsync(Object o)
```
    Description copied from interface: RCollectionAsync
    
    Returns true if this collection contains encoded state of the specified element.
    
    Specified by:
    
    containsAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    o - element whose presence in this collection is to be tested
    
    Returns:
    
    true if this collection contains the specified element and false otherwise
  - containsAllAsync
```
public RFuture<Boolean> containsAllAsync(Collection<?> c)
```
    Description copied from interface: RCollectionAsync
    
    Returns true if this collection contains all of the elements in the specified collection.
    
    Specified by:
    
    containsAllAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    c - collection to be checked for containment in this collection
    
    Returns:
    
    true if this collection contains all of the elements in the specified collection
  - removeAsync
```
public RFuture<Boolean> removeAsync(Object o)
```
    Description copied from interface: RCollectionAsync
    
    Removes a single instance of the specified element from this collection, if it is present.
    
    Specified by:
    
    removeAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    o - element to be removed from this collection, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - addAllAsync
```
public RFuture<Boolean> addAllAsync(Collection<? extends V> c)
```
    Description copied from interface: RCollectionAsync
    
    Adds all elements contained in the specified collection
    
    Specified by:
    
    addAllAsync in interface RCollectionAsync<V>
    
    Parameters:
    
    c - - collection of elements to add
    
    Returns:
    
    true if at least one element was added and false if all elements are already present
  - expire
```
public boolean expire(long timeToLive,
                      TimeUnit timeUnit)
```
    Description copied from interface: RExpirable
    
    Use RExpirable.expire(Duration) instead
    
    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
    
    Use RExpirableAsync.expireAsync(Duration) instead
    
    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
    
    Use RExpirable.expire(Instant) instead
    
    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
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(long timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Use RExpirableAsync.expireAsync(Instant) instead
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    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
    
    Sets an expiration date for this 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
  - expireIfSet
```
public boolean expireIfSet(Instant time)
```
    Description copied from interface: RExpirable
    
    Sets an expiration date for this object only if it has been already set. When expire date comes the object will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfSet in interface RExpirable
    
    Parameters:
    
    time - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfSetAsync
```
public RFuture<Boolean> expireIfSetAsync(Instant time)
```
    Specified by:
    
    expireIfSetAsync in interface RExpirableAsync
  - expireIfNotSet
```
public boolean expireIfNotSet(Instant time)
```
    Description copied from interface: RExpirable
    
    Sets an expiration date for this object only if it hasn't been set before. When expire date comes the object will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfNotSet in interface RExpirable
    
    Parameters:
    
    time - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfNotSetAsync
```
public RFuture<Boolean> expireIfNotSetAsync(Instant time)
```
    Specified by:
    
    expireIfNotSetAsync in interface RExpirableAsync
  - expireIfGreater
```
public boolean expireIfGreater(Instant time)
```
    Description copied from interface: RExpirable
    
    Sets an expiration date for this object only if it's greater than expiration date set before. When expire date comes the object will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfGreater in interface RExpirable
    
    Parameters:
    
    time - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfGreaterAsync
```
public RFuture<Boolean> expireIfGreaterAsync(Instant time)
```
    Specified by:
    
    expireIfGreaterAsync in interface RExpirableAsync
  - expireIfLess
```
public boolean expireIfLess(Instant time)
```
    Description copied from interface: RExpirable
    
    Sets an expiration date for this object only if it's less than expiration date set before. When expire date comes the object will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfLess in interface RExpirable
    
    Parameters:
    
    time - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfLessAsync
```
public RFuture<Boolean> expireIfLessAsync(Instant time)
```
    Specified by:
    
    expireIfLessAsync in interface RExpirableAsync
  - 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
  - expire
```
public boolean expire(Duration duration)
```
    Description copied from interface: RExpirable
    
    Sets a timeout for this object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAsync
```
public RFuture<Boolean> expireAsync(Duration duration)
```
    Description copied from interface: RExpirableAsync
    
    Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(Date timestamp)
```
    Description copied from interface: RExpirable
    
    Use RExpirable.expire(Instant) instead
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(Date timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Use RExpirableAsync.expireAsync(Instant) instead
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfSet
```
public boolean expireIfSet(Duration duration)
```
    Description copied from interface: RExpirable
    
    Sets a timeout for this object only if it has been already set. After the timeout has expired, the key will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfSet in interface RExpirable
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfSetAsync
```
public RFuture<Boolean> expireIfSetAsync(Duration duration)
```
    Specified by:
    
    expireIfSetAsync in interface RExpirableAsync
  - expireIfNotSet
```
public boolean expireIfNotSet(Duration duration)
```
    Description copied from interface: RExpirable
    
    Sets a timeout for this object only if it hasn't been set before. After the timeout has expired, the key will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfNotSet in interface RExpirable
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfNotSetAsync
```
public RFuture<Boolean> expireIfNotSetAsync(Duration duration)
```
    Specified by:
    
    expireIfNotSetAsync in interface RExpirableAsync
  - expireIfGreater
```
public boolean expireIfGreater(Duration duration)
```
    Description copied from interface: RExpirable
    
    Sets a timeout for this object only if it's greater than timeout set before. After the timeout has expired, the key will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfGreater in interface RExpirable
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfGreaterAsync
```
public RFuture<Boolean> expireIfGreaterAsync(Duration duration)
```
    Specified by:
    
    expireIfGreaterAsync in interface RExpirableAsync
  - expireIfLess
```
public boolean expireIfLess(Duration duration)
```
    Description copied from interface: RExpirable
    
    Sets a timeout for this object only if it's less than timeout set before. After the timeout has expired, the key will automatically be deleted.
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    expireIfLess in interface RExpirable
    
    Parameters:
    
    duration - timeout before object will be deleted
    
    Returns:
    
    true if the timeout was set and false if not
  - expireIfLessAsync
```
public RFuture<Boolean> expireIfLessAsync(Duration duration)
```
    Specified by:
    
    expireIfLessAsync in interface RExpirableAsync
  - 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.
  - getExpireTime
```
public long getExpireTime()
```
    Description copied from interface: RExpirable
    
    Expiration time of Redisson object that has a timeout
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    getExpireTime in interface RExpirable
    
    Returns:
    
    expiration time
  - getExpireTimeAsync
```
public RFuture<Long> getExpireTimeAsync()
```
    Description copied from interface: RExpirableAsync
    
    Expiration time of Redisson object that has a timeout
    Requires Redis 7.0.0 and higher.
    
    Specified by:
    
    getExpireTimeAsync in interface RExpirableAsync
    
    Returns:
    
    expiration time
  - expireAsync
```
protected RFuture<Boolean> expireAsync(long timeToLive,
                                       TimeUnit timeUnit,
                                       String param,
                                       String... keys)
```
  - expireAtAsync
```
protected RFuture<Boolean> expireAtAsync(long timestamp,
                                         String param,
                                         String... keys)
```
  - clearExpireAsync
```
protected RFuture<Boolean> clearExpireAsync(String... keys)
```

Class RedissonTransferQueue<V>

Nested Class Summary

Field Summary

Fields inherited from class org.redisson.RedissonObject

Constructor Summary

Method Summary

Methods inherited from class org.redisson.RedissonObject

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.redisson.api.RExpirable

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObject

Methods inherited from interface org.redisson.api.RObjectAsync

Methods inherited from interface org.redisson.api.RQueue

Methods inherited from interface org.redisson.api.RQueueAsync

Constructor Detail

RedissonTransferQueue

RedissonTransferQueue

Method Detail

tryTransfer

tryTransferAsync

transfer

transferAsync

tryTransfer

tryTransferAsync

hasWaitingConsumer

getWaitingConsumerCount

add

addAsync

offer

remove

poll

pollAsync

element

peek

peekAsync

put

offer

take

takeAsync

poll

pollAsync

remainingCapacity

remove

containsAll

addAll

removeAll

retainAll

clear

clearAsync

size

sizeAsync

isEmpty

contains

getValueAsync

iterator

toArray

toArray

drainTo

drainToAsync

drainTo

drainToAsync

readAll

readAllAsync

pollFromAny

pollFirstFromAny

pollLastFromAny

pollFirstFromAnyAsync

pollLastFromAnyAsync

pollLastAndOfferFirstTo

takeLastAndOfferFirstTo

subscribeOnElements

unsubscribe

pollLastAndOfferFirstTo

poll

pollFromAnyAsync

pollLastAndOfferFirstToAsync

takeLastAndOfferFirstToAsync

putAsync