Uses of Interface
org.redisson.api.RFuture

Packages that use RFuture

Package	Description
org.redisson
org.redisson.api
org.redisson.api.mapreduce
org.redisson.api.redisnode
org.redisson.cache
org.redisson.client
org.redisson.client.handler
org.redisson.command
org.redisson.connection
org.redisson.executor
org.redisson.jcache
org.redisson.misc
org.redisson.reactive
org.redisson.redisnode
org.redisson.rx
org.redisson.transaction
org.redisson.transaction.operation

Uses of RFuture in org.redisson

Methods in org.redisson that return RFuture

Modifier and Type	Method	Description
RFuture<Long>	RedissonStream.ackAsync(String groupName, StreamMessageId... ids)
RFuture<String>	RedissonPermitExpirableSemaphore.acquireAsync()
RFuture<String>	RedissonPermitExpirableSemaphore.acquireAsync(long leaseTime, TimeUnit timeUnit)
RFuture<Void>	RedissonRateLimiter.acquireAsync()
RFuture<Void>	RedissonRateLimiter.acquireAsync(long permits)
RFuture<Void>	RedissonSemaphore.acquireAsync()
RFuture<Void>	RedissonSemaphore.acquireAsync(int permits)
RFuture<Integer>	RedissonList.addAfterAsync(V elementToFind, V element)
RFuture<Integer>	RedissonListMultimapValues.addAfterAsync(V elementToFind, V element)
RFuture<Boolean>	RedissonBoundedBlockingQueue.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonDelayedQueue.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonHyperLogLog.addAllAsync(Collection<V> objects)
RFuture<Boolean>	RedissonLexSortedSet.addAllAsync(Collection<? extends String> c)
RFuture<Boolean>	RedissonList.addAllAsync(int index, Collection<? extends V> coll)
RFuture<Boolean>	RedissonList.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonListMultimapValues.addAllAsync(int index, Collection<? extends V> coll)
RFuture<Boolean>	RedissonListMultimapValues.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonRingBuffer.addAllAsync(Collection<? extends V> c)
RFuture<Integer>	RedissonScoredSortedSet.addAllAsync(Map<V,Double> objects)
RFuture<Boolean>	RedissonSet.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonSetCache.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonSetMultimapValues.addAllAsync(Collection<? extends V> c)
RFuture<StreamMessageId>	RedissonStream.addAllAsync(Map<K,V> entries)
RFuture<StreamMessageId>	RedissonStream.addAllAsync(Map<K,V> entries, int trimLen, boolean trimStrict)
RFuture<Void>	RedissonStream.addAllAsync(StreamMessageId id, Map<K,V> entries)
RFuture<Void>	RedissonStream.addAllAsync(StreamMessageId id, Map<K,V> entries, int trimLen, boolean trimStrict)
RFuture<Boolean>	RedissonSubList.addAllAsync(int index, Collection<? extends V> coll)
RFuture<Boolean>	RedissonSubList.addAllAsync(Collection<? extends V> c)
RFuture<Void>	RedissonTimeSeries.addAllAsync(Collection<TimeSeriesEntry<V,L>> entries)
RFuture<Void>	RedissonTimeSeries.addAllAsync(Collection<TimeSeriesEntry<V,L>> entries, Duration timeToLive)
RFuture<Void>	RedissonTimeSeries.addAllAsync(Map<Long,V> objects)
RFuture<Void>	RedissonTimeSeries.addAllAsync(Map<Long,V> objects, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonTransferQueue.addAllAsync(Collection<? extends V> c)
RFuture<Integer>	RedissonSet.addAllCountedAsync(Collection<? extends V> c)
RFuture<Integer>	RedissonSetMultimapValues.addAllCountedAsync(Collection<? extends V> c)
RFuture<Integer>	RedissonScoredSortedSet.addAllIfAbsentAsync(Map<V,Double> objects)
RFuture<Integer>	RedissonScoredSortedSet.addAllIfExistAsync(Map<V,Double> objects)
RFuture<Integer>	RedissonScoredSortedSet.addAllIfGreaterAsync(Map<V,Double> objects)
RFuture<Integer>	RedissonScoredSortedSet.addAllIfLessAsync(Map<V,Double> objects)
RFuture<Double>	RedissonAtomicDouble.addAndGetAsync(double delta)
RFuture<Long>	RedissonAtomicLong.addAndGetAsync(long delta)
protected abstract RFuture<T>	RedissonBaseAdder.addAndGetAsync(String id)
protected RFuture<Double>	RedissonDoubleAdder.addAndGetAsync(String id)
protected RFuture<Long>	RedissonLongAdder.addAndGetAsync(String id)
RFuture<V>	RedissonMap.addAndGetAsync(K key, Number value)
protected RFuture<V>	RedissonLocalCachedMap.addAndGetOperationAsync(K key, Number value)
protected RFuture<V>	RedissonMap.addAndGetOperationAsync(K key, Number value)
protected RFuture<V>	RedissonMapCache.addAndGetOperationAsync(K key, Number value)
RFuture<Integer>	RedissonScoredSortedSet.addAndGetRankAsync(double score, V object)
RFuture<Integer>	RedissonScoredSortedSet.addAndGetRevRankAsync(double score, V object)
RFuture<List<Integer>>	RedissonScoredSortedSet.addAndGetRevRankAsync(Map<? extends V,Double> map)
RFuture<Boolean>	RedissonBoundedBlockingQueue.addAsync(V e)
RFuture<Boolean>	RedissonDelayedQueue.addAsync(V e)
RFuture<Long>	RedissonGeo.addAsync(double longitude, double latitude, V member)
RFuture<Long>	RedissonGeo.addAsync(GeoEntry... entries)
RFuture<Boolean>	RedissonHyperLogLog.addAsync(V obj)
RFuture<Boolean>	RedissonLexSortedSet.addAsync(String e)
RFuture<Boolean>	RedissonList.addAsync(int index, V element)
RFuture<Boolean>	RedissonList.addAsync(V e)
protected <T> RFuture<T>	RedissonList.addAsync(V e, RedisCommand<T> command)
RFuture<Boolean>	RedissonListMultimapValues.addAsync(int index, V element)
RFuture<Boolean>	RedissonListMultimapValues.addAsync(V e)
RFuture<Boolean>	RedissonPriorityQueue.addAsync(V e)
RFuture<Boolean>	RedissonRingBuffer.addAsync(V e)
RFuture<Boolean>	RedissonScoredSortedSet.addAsync(double score, V object)
RFuture<Boolean>	RedissonSet.addAsync(V e)
RFuture<Boolean>	RedissonSetCache.addAsync(V value)
RFuture<Boolean>	RedissonSetCache.addAsync(V value, long ttl, TimeUnit unit)
RFuture<Boolean>	RedissonSetMultimapValues.addAsync(V e)
RFuture<Boolean>	RedissonSortedSet.addAsync(V value)
RFuture<StreamMessageId>	RedissonStream.addAsync(K key, V value)
RFuture<StreamMessageId>	RedissonStream.addAsync(K key, V value, int trimLen, boolean trimStrict)
RFuture<StreamMessageId>	RedissonStream.addAsync(StreamAddArgs<K,V> args)
RFuture<Void>	RedissonStream.addAsync(StreamMessageId id, K key, V value)
RFuture<Void>	RedissonStream.addAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict)
RFuture<Void>	RedissonStream.addAsync(StreamMessageId id, StreamAddArgs<K,V> args)
RFuture<Boolean>	RedissonSubList.addAsync(V e)
RFuture<Void>	RedissonTimeSeries.addAsync(long timestamp, V object)
RFuture<Void>	RedissonTimeSeries.addAsync(long timestamp, V object, long timeToLive, TimeUnit timeUnit)
RFuture<Void>	RedissonTimeSeries.addAsync(long timestamp, V object, L label)
RFuture<Void>	RedissonTimeSeries.addAsync(long timestamp, V object, L label, Duration timeToLive)
RFuture<Boolean>	RedissonTransferQueue.addAsync(V v)
RFuture<Integer>	RedissonList.addBeforeAsync(V elementToFind, V element)
RFuture<Integer>	RedissonListMultimapValues.addBeforeAsync(V elementToFind, V element)
<R> RFuture<R>	RedissonStream.addCustomAsync(StreamMessageId id, StreamAddArgs<K,V> args)
RFuture<Void>	RedissonDeque.addFirstAsync(V e)
RFuture<Integer>	RedissonDeque.addFirstAsync(V... elements)
RFuture<Void>	RedissonPriorityDeque.addFirstAsync(V e)
RFuture<Integer>	RedissonPriorityDeque.addFirstAsync(V... elements)
RFuture<Integer>	RedissonDeque.addFirstIfExistsAsync(V... elements)
RFuture<Integer>	RedissonPriorityDeque.addFirstIfExistsAsync(V... elements)
RFuture<Boolean>	RedissonScoredSortedSet.addIfAbsentAsync(double score, V object)
RFuture<Boolean>	RedissonGeo.addIfExistsAsync(double longitude, double latitude, V member)
RFuture<Long>	RedissonGeo.addIfExistsAsync(GeoEntry... entries)
RFuture<Boolean>	RedissonScoredSortedSet.addIfExistsAsync(double score, V object)
RFuture<Boolean>	RedissonScoredSortedSet.addIfGreaterAsync(double score, V object)
RFuture<Boolean>	RedissonScoredSortedSet.addIfLessAsync(double score, V object)
RFuture<Void>	RedissonDeque.addLastAsync(V e)
RFuture<Integer>	RedissonDeque.addLastAsync(V... elements)
RFuture<Void>	RedissonPriorityDeque.addLastAsync(V e)
RFuture<Integer>	RedissonPriorityDeque.addLastAsync(V... elements)
RFuture<Integer>	RedissonDeque.addLastIfExistsAsync(V... elements)
RFuture<Integer>	RedissonPriorityDeque.addLastIfExistsAsync(V... elements)
RFuture<Integer>	RedissonBucket.addListenerAsync(ObjectListener listener)
RFuture<Integer>	RedissonList.addListenerAsync(ObjectListener listener)
protected final <T extends ObjectListener> RFuture<Integer>	RedissonObject.addListenerAsync(String name, T listener, BiConsumer<T,String> consumer)
RFuture<Integer>	RedissonObject.addListenerAsync(ObjectListener listener)
<T> RFuture<Integer>	RedissonPatternTopic.addListenerAsync(Class<T> type, PatternMessageListener<T> listener)
RFuture<Integer>	RedissonPatternTopic.addListenerAsync(PatternStatusListener listener)
<M> RFuture<String>	RedissonReliableTopic.addListenerAsync(Class<M> type, MessageListener<M> listener)
RFuture<Integer>	RedissonScoredSortedSet.addListenerAsync(ObjectListener listener)
protected RFuture<Integer>	RedissonShardedTopic.addListenerAsync(RedisPubSubListener<?> pubSubListener)
<M> RFuture<Integer>	RedissonTopic.addListenerAsync(Class<M> type, MessageListener<M> listener)
RFuture<Integer>	RedissonTopic.addListenerAsync(StatusListener listener)
protected RFuture<Integer>	RedissonTopic.addListenerAsync(RedisPubSubListener<?> pubSubListener)
RFuture<Void>	RedissonPermitExpirableSemaphore.addPermitsAsync(int permits)
RFuture<Void>	RedissonSemaphore.addPermitsAsync(int permits)
RFuture<Integer>	RedissonScoredSortedSet.addScoreAndGetRankAsync(V object, Number value)
RFuture<Integer>	RedissonScoredSortedSet.addScoreAndGetRevRankAsync(V object, Number value)
RFuture<Double>	RedissonScoredSortedSet.addScoreAsync(V object, Number value)
RFuture<Void>	RedissonBitSet.andAsync(String... bitSetNames)
RFuture<Long>	RedissonJsonBucket.arrayAppendAsync(String path, Object... values)
RFuture<List<Long>>	RedissonJsonBucket.arrayAppendMultiAsync(String path, Object... values)
RFuture<Long>	RedissonJsonBucket.arrayIndexAsync(String path, Object value)
RFuture<Long>	RedissonJsonBucket.arrayIndexAsync(String path, Object value, long start, long end)
RFuture<List<Long>>	RedissonJsonBucket.arrayIndexMultiAsync(String path, Object value)
RFuture<List<Long>>	RedissonJsonBucket.arrayIndexMultiAsync(String path, Object value, long start, long end)
RFuture<Long>	RedissonJsonBucket.arrayInsertAsync(String path, long index, Object... values)
RFuture<List<Long>>	RedissonJsonBucket.arrayInsertMultiAsync(String path, long index, Object... values)
<T> RFuture<T>	RedissonJsonBucket.arrayPollFirstAsync(JsonCodec<T> codec, String path)
<T> RFuture<List<T>>	RedissonJsonBucket.arrayPollFirstMultiAsync(JsonCodec<T> codec, String path)
<T> RFuture<T>	RedissonJsonBucket.arrayPollLastAsync(JsonCodec<T> codec, String path)
<T> RFuture<List<T>>	RedissonJsonBucket.arrayPollLastMultiAsync(JsonCodec<T> codec, String path)
<T> RFuture<T>	RedissonJsonBucket.arrayPopAsync(JsonCodec<T> codec, String path, long index)
<T> RFuture<List<T>>	RedissonJsonBucket.arrayPopMultiAsync(JsonCodec<T> codec, String path, long index)
RFuture<Long>	RedissonJsonBucket.arraySizeAsync(String path)
RFuture<List<Long>>	RedissonJsonBucket.arraySizeMultiAsync(String path)
RFuture<Long>	RedissonJsonBucket.arrayTrimAsync(String path, long start, long end)
RFuture<List<Long>>	RedissonJsonBucket.arrayTrimMultiAsync(String path, long start, long end)
RFuture<AutoClaimResult<K,V>>	RedissonStream.autoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count)
RFuture<Integer>	RedissonPermitExpirableSemaphore.availablePermitsAsync()
RFuture<Long>	RedissonRateLimiter.availablePermitsAsync()
RFuture<Integer>	RedissonSemaphore.availablePermitsAsync()
RFuture<Void>	RedissonCountDownLatch.awaitAsync()
RFuture<Boolean>	RedissonCountDownLatch.awaitAsync(long waitTime, TimeUnit unit)
<R> RFuture<R>	RedissonFuction.callAsync(String key, FunctionMode mode, String name, FunctionResult returnType, List<Object> keys, Object... values)
<R> RFuture<R>	RedissonFuction.callAsync(FunctionMode mode, String name, FunctionResult returnType)
<R> RFuture<R>	RedissonFuction.callAsync(FunctionMode mode, String name, FunctionResult returnType, List<Object> keys, Object... values)
RFuture<Boolean>	RedissonExecutorService.cancelTaskAsync(String taskId)
RFuture<Integer>	RedissonRingBuffer.capacityAsync()
RFuture<Long>	RedissonBitSet.cardinalityAsync()
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.claimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId... ids)
RFuture<Void>	RedissonBitSet.clearAsync()
RFuture<Boolean>	RedissonBitSet.clearAsync(long bitIndex)
RFuture<Void>	RedissonBitSet.clearAsync(long fromIndex, long toIndex)
RFuture<Long>	RedissonJsonBucket.clearAsync()
RFuture<Long>	RedissonJsonBucket.clearAsync(String path)
RFuture<Void>	RedissonTransferQueue.clearAsync()
RFuture<Boolean>	RedissonBloomFilter.clearExpireAsync()
RFuture<Boolean>	RedissonBoundedBlockingQueue.clearExpireAsync()
RFuture<Boolean>	RedissonDelayedQueue.clearExpireAsync()
RFuture<Boolean>	RedissonFairLock.clearExpireAsync()
RFuture<Boolean>	RedissonIdGenerator.clearExpireAsync()
RFuture<Boolean>	RedissonKeys.clearExpireAsync(String name)
RFuture<Boolean>	RedissonListMultimapCache.clearExpireAsync()
RFuture<Boolean>	RedissonListMultimapValues.clearExpireAsync()
RFuture<Boolean>	RedissonMapCache.clearExpireAsync()
RFuture<Boolean>	RedissonMultimap.clearExpireAsync()
RFuture<Boolean>	RedissonMultimapCache.clearExpireAsync()
RFuture<Boolean>	RedissonPermitExpirableSemaphore.clearExpireAsync()
RFuture<Boolean>	RedissonPriorityQueue.clearExpireAsync()
RFuture<Boolean>	RedissonRateLimiter.clearExpireAsync()
RFuture<Boolean>	RedissonReliableTopic.clearExpireAsync()
RFuture<Boolean>	RedissonSetMultimapCache.clearExpireAsync()
RFuture<Boolean>	RedissonSetMultimapValues.clearExpireAsync()
RFuture<Boolean>	RedissonTimeSeries.clearExpireAsync()
RFuture<Void>	RedissonLocalCachedMap.clearLocalCacheAsync()
RFuture<Boolean>	RedissonAtomicDouble.compareAndSetAsync(double expect, double update)
RFuture<Boolean>	RedissonAtomicLong.compareAndSetAsync(long expect, long update)
RFuture<Boolean>	RedissonBucket.compareAndSetAsync(V expect, V update)
RFuture<Boolean>	RedissonJsonBucket.compareAndSetAsync(String path, Object expect, Object update)
RFuture<Boolean>	RedissonJsonBucket.compareAndSetAsync(V expect, V update)
protected RFuture<Boolean>	RedissonJsonBucket.compareAndSetUpdateAsync(String path, Object expect, Object update)
RFuture<V>	RedissonMap.computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
RFuture<V>	RedissonMap.computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction)
RFuture<V>	RedissonMap.computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
RFuture<Boolean>	RedissonDelayedQueue.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonList.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonListMultimapValues.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonScoredSortedSet.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSet.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSetCache.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSetMultimapValues.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSubList.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransferQueue.containsAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonDelayedQueue.containsAsync(Object o)
RFuture<Boolean>	RedissonList.containsAsync(Object o)
RFuture<Boolean>	RedissonListMultimapValues.containsAsync(Object o)
RFuture<Boolean>	RedissonScoredSortedSet.containsAsync(Object o)
RFuture<Boolean>	RedissonSet.containsAsync(Object o)
RFuture<Boolean>	RedissonSetCache.containsAsync(Object o)
RFuture<Boolean>	RedissonSetMultimapValues.containsAsync(Object o)
RFuture<Boolean>	RedissonTransferQueue.containsAsync(Object o)
RFuture<Boolean>	RedissonListMultimap.containsEntryAsync(Object key, Object value)
RFuture<Boolean>	RedissonListMultimapCache.containsEntryAsync(Object key, Object value)
RFuture<Boolean>	RedissonSetMultimap.containsEntryAsync(Object key, Object value)
RFuture<Boolean>	RedissonSetMultimapCache.containsEntryAsync(Object key, Object value)
RFuture<Boolean>	RedissonListMultimap.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonListMultimapCache.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonLocalCachedMap.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonMap.containsKeyAsync(Object key)
protected RFuture<Boolean>	RedissonMap.containsKeyAsync(Object key, CompletableFuture<V> promise)
RFuture<Boolean>	RedissonSetMultimap.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonSetMultimapCache.containsKeyAsync(Object key)
protected RFuture<Boolean>	RedissonMap.containsKeyOperationAsync(String name, Object key)
protected RFuture<Boolean>	RedissonMapCache.containsKeyOperationAsync(String name, Object key)
RFuture<Boolean>	RedissonListMultimap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonListMultimapCache.containsValueAsync(Object value)
RFuture<Boolean>	RedissonLocalCachedMap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonMap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonMapCache.containsValueAsync(Object value)
RFuture<Boolean>	RedissonSetMultimap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonSetMultimapCache.containsValueAsync(Object value)
RFuture<Void>	RedissonKeys.copyAsync(String name, String host, int port, int database, long timeout)
RFuture<Void>	RedissonObject.copyAsync(String host, int port, int database, long timeout)
RFuture<Long>	RedissonHyperLogLog.countAsync()
RFuture<Long>	RedissonKeys.countAsync()
RFuture<Integer>	RedissonLexSortedSet.countAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)
RFuture<Integer>	RedissonScoredSortedSet.countAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Void>	RedissonCountDownLatch.countDownAsync()
RFuture<Long>	RedissonKeys.countExistsAsync(String... names)
RFuture<Integer>	RedissonLexSortedSet.countHeadAsync(String toElement, boolean toInclusive)
RFuture<Integer>	RedissonScoredSortedSet.countIntersectionAsync(int limit, String... names)
RFuture<Integer>	RedissonScoredSortedSet.countIntersectionAsync(String... names)
RFuture<Integer>	RedissonSet.countIntersectionAsync(int limit, String... names)
RFuture<Integer>	RedissonSet.countIntersectionAsync(String... names)
RFuture<Integer>	RedissonSetMultimapValues.countIntersectionAsync(int limit, String... names)
RFuture<Integer>	RedissonSetMultimapValues.countIntersectionAsync(String... names)
RFuture<Long>	RedissonJsonBucket.countKeysAsync()
RFuture<Long>	RedissonJsonBucket.countKeysAsync(String path)
RFuture<List<Long>>	RedissonJsonBucket.countKeysMultiAsync(String path)
RFuture<Integer>	RedissonReliableTopic.countSubscribersAsync()
RFuture<Long>	RedissonShardedTopic.countSubscribersAsync()
RFuture<Long>	RedissonTopic.countSubscribersAsync()
RFuture<Integer>	RedissonLexSortedSet.countTailAsync(String fromElement, boolean fromInclusive)
RFuture<Long>	RedissonHyperLogLog.countWithAsync(String... otherLogNames)
RFuture<Void>	RedissonStream.createConsumerAsync(String groupName, String consumerName)
RFuture<Void>	RedissonStream.createGroupAsync(String groupName)
RFuture<Void>	RedissonStream.createGroupAsync(String groupName, StreamMessageId id)
RFuture<Double>	RedissonAtomicDouble.decrementAndGetAsync()
RFuture<Long>	RedissonAtomicLong.decrementAndGetAsync()
RFuture<Long>	RedissonLiveObjectService.delete(Object id, Class<?> entityClass, NamingScheme namingScheme, CommandBatchService ce)
RFuture<Boolean>	RedissonBaseLock.deleteAsync()
RFuture<Boolean>	RedissonBloomFilter.deleteAsync()
RFuture<Boolean>	RedissonBoundedBlockingQueue.deleteAsync()
RFuture<Boolean>	RedissonCountDownLatch.deleteAsync()
RFuture<Boolean>	RedissonDelayedQueue.deleteAsync()
RFuture<Boolean>	RedissonExecutorService.deleteAsync()
RFuture<Boolean>	RedissonFairLock.deleteAsync()
RFuture<Void>	RedissonFuction.deleteAsync(String libraryName)
RFuture<Boolean>	RedissonIdGenerator.deleteAsync()
RFuture<Boolean>	RedissonJsonBucket.deleteAsync()
RFuture<Long>	RedissonJsonBucket.deleteAsync(String path)
RFuture<Long>	RedissonKeys.deleteAsync(String... keys)
RFuture<Long>	RedissonKeys.deleteAsync(RObject... objects)
RFuture<Boolean>	RedissonListMultimapCache.deleteAsync()
RFuture<Boolean>	RedissonListMultimapValues.deleteAsync()
RFuture<Boolean>	RedissonLocalCachedMap.deleteAsync()
RFuture<Boolean>	RedissonMapCache.deleteAsync()
RFuture<Boolean>	RedissonMultimap.deleteAsync()
RFuture<Boolean>	RedissonMultimapCache.deleteAsync()
RFuture<Boolean>	RedissonObject.deleteAsync()
protected RFuture<Boolean>	RedissonObject.deleteAsync(String... keys)
RFuture<Boolean>	RedissonPermitExpirableSemaphore.deleteAsync()
RFuture<Boolean>	RedissonPriorityQueue.deleteAsync()
RFuture<Boolean>	RedissonRateLimiter.deleteAsync()
RFuture<Boolean>	RedissonReliableTopic.deleteAsync()
RFuture<Boolean>	RedissonSetMultimapCache.deleteAsync()
RFuture<Boolean>	RedissonSetMultimapValues.deleteAsync()
RFuture<Boolean>	RedissonTimeSeries.deleteAsync()
RFuture<Long>	RedissonKeys.deleteByPatternAsync(String pattern)
RFuture<Integer>	RedissonScoredSortedSet.diffAsync(String... names)
RFuture<Integer>	RedissonSet.diffAsync(String... names)
RFuture<Integer>	RedissonSetMultimapValues.diffAsync(String... names)
RFuture<Void>	RedissonBatch.discardAsync()
RFuture<Double>	RedissonGeo.distAsync(V firstMember, V secondMember, GeoUnit geoUnit)
RFuture<Integer>	RedissonSemaphore.drainPermitsAsync()
RFuture<Integer>	RedissonBlockingDeque.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonBlockingDeque.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<Integer>	RedissonBlockingQueue.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonBlockingQueue.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<Integer>	RedissonBoundedBlockingQueue.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonBoundedBlockingQueue.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<Integer>	RedissonPriorityBlockingDeque.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonPriorityBlockingDeque.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<Integer>	RedissonPriorityBlockingQueue.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonPriorityBlockingQueue.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<Integer>	RedissonTransferQueue.drainToAsync(Collection<? super V> c)
RFuture<Integer>	RedissonTransferQueue.drainToAsync(Collection<? super V> c, int maxElements)
RFuture<byte[]>	RedissonFuction.dumpAsync()
RFuture<byte[]>	RedissonObject.dumpAsync()
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeAsync(int startIndex, int endIndex)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.entryRangeAsync(long startTimestamp, long endTimestamp)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.entryRangeAsync(long startTimestamp, long endTimestamp, int limit)
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Collection<ScoredEntry<V>>>	RedissonScoredSortedSet.entryRangeReversedAsync(int startIndex, int endIndex)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.entryRangeReversedAsync(long startTimestamp, long endTimestamp)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.entryRangeReversedAsync(long startTimestamp, long endTimestamp, int limit)
<R> RFuture<R>	RedissonScript.evalAsync(String key, RScript.Mode mode, String luaScript, RScript.ReturnType returnType, List<Object> keys, Object... values)
<R> RFuture<R>	RedissonScript.evalAsync(RScript.Mode mode, String luaScript, RScript.ReturnType returnType)
<R> RFuture<R>	RedissonScript.evalAsync(RScript.Mode mode, String luaScript, RScript.ReturnType returnType, List<Object> keys, Object... values)
<R> RFuture<R>	RedissonScript.evalShaAsync(String key, RScript.Mode mode, String shaDigest, RScript.ReturnType returnType, List<Object> keys, Object... values)
<R> RFuture<R>	RedissonScript.evalShaAsync(String key, RScript.Mode mode, Codec codec, String shaDigest, RScript.ReturnType returnType, List<Object> keys, Object... values)
<R> RFuture<R>	RedissonScript.evalShaAsync(RScript.Mode mode, String shaDigest, RScript.ReturnType returnType)
<R> RFuture<R>	RedissonScript.evalShaAsync(RScript.Mode mode, String shaDigest, RScript.ReturnType returnType, List<Object> keys, Object... values)
protected <T> RFuture<T>	RedissonBaseLock.evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
RFuture<BatchResult<?>>	RedissonBatch.executeAsync()
RFuture<Boolean>	RedissonBloomFilter.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonBoundedBlockingQueue.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonDelayedQueue.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonFairLock.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonIdGenerator.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonKeys.expireAsync(String name, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonListMultimapCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
protected RFuture<Boolean>	RedissonListMultimapValues.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonMapCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonMultimap.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonMultimapCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param)
RFuture<Boolean>	RedissonPermitExpirableSemaphore.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonPriorityQueue.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonRateLimiter.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonReliableTopic.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonSetMultimapCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonSetMultimapValues.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonTimeSeries.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
protected RFuture<Boolean>	RedissonBloomFilter.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonBoundedBlockingQueue.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonDelayedQueue.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonFairLock.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonIdGenerator.expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	RedissonKeys.expireAtAsync(String name, long timestamp)
protected RFuture<Boolean>	RedissonListMultimapCache.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonListMultimapValues.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonMapCache.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonMultimap.expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	RedissonMultimapCache.expireAtAsync(long timestamp, String param)
protected RFuture<Boolean>	RedissonPermitExpirableSemaphore.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonPriorityQueue.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonRateLimiter.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonReliableTopic.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonSetMultimapCache.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonSetMultimapValues.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTimeSeries.expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	RedissonListMultimapCache.expireKeyAsync(K key, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonMultimapCache.expireKeyAsync(K key, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonSetMultimapCache.expireKeyAsync(K key, long timeToLive, TimeUnit timeUnit)
RFuture<FastAutoClaimResult>	RedissonStream.fastAutoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count)
RFuture<List<StreamMessageId>>	RedissonStream.fastClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId... ids)
RFuture<Boolean>	RedissonMap.fastPutAsync(K key, V value)
RFuture<Boolean>	RedissonMapCache.fastPutAsync(K key, V value, long ttl, TimeUnit ttlUnit)
RFuture<Boolean>	RedissonMapCache.fastPutAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<Boolean>	RedissonLocalCachedMap.fastPutIfAbsentAsync(K key, V value)
RFuture<Boolean>	RedissonMap.fastPutIfAbsentAsync(K key, V value)
RFuture<Boolean>	RedissonMapCache.fastPutIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<Boolean>	RedissonMap.fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.fastPutIfAbsentOperationAsync(K key, V value)
RFuture<Boolean>	RedissonLocalCachedMap.fastPutIfExistsAsync(K key, V value)
RFuture<Boolean>	RedissonMap.fastPutIfExistsAsync(K key, V value)
protected RFuture<Boolean>	RedissonMap.fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonLocalCachedMap.fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMap.fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.fastPutOperationAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<Void>	RedissonList.fastRemoveAsync(int index)
RFuture<Void>	RedissonListMultimapValues.fastRemoveAsync(int index)
RFuture<Long>	RedissonMap.fastRemoveAsync(K... keys)
protected <T> RFuture<T>	RedissonMultimap.fastRemoveAsync(List<Object> mapKeys, List<Object> listKeys, RedisCommand<T> evalCommandType)
RFuture<Long>	RedissonMultimap.fastRemoveAsync(K... keys)
protected RFuture<Long>	RedissonLocalCachedMap.fastRemoveOperationAsync(K... keys)
protected RFuture<Long>	RedissonMap.fastRemoveOperationAsync(K... keys)
protected RFuture<Long>	RedissonMapCache.fastRemoveOperationAsync(K... keys)
protected RFuture<List<Long>>	RedissonLocalCachedMap.fastRemoveOperationBatchAsync(K... keys)
protected RFuture<List<Long>>	RedissonMap.fastRemoveOperationBatchAsync(K... keys)
protected RFuture<List<Long>>	RedissonMapCache.fastRemoveOperationBatchAsync(K... keys)
RFuture<Boolean>	RedissonLocalCachedMap.fastReplaceAsync(K key, V value)
RFuture<Boolean>	RedissonMap.fastReplaceAsync(K key, V value)
protected RFuture<Boolean>	RedissonLocalCachedMap.fastReplaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMap.fastReplaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.fastReplaceOperationAsync(K key, V value)
RFuture<Void>	RedissonList.fastSetAsync(int index, V element)
RFuture<Void>	RedissonListMultimapValues.fastSetAsync(int index, V element)
RFuture<Void>	RedissonSubList.fastSetAsync(int index, V element)
RFuture<V>	RedissonScoredSortedSet.firstAsync()
RFuture<V>	RedissonTimeSeries.firstAsync()
RFuture<Collection<V>>	RedissonTimeSeries.firstAsync(int count)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.firstEntriesAsync(int count)
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.firstEntryAsync()
RFuture<Double>	RedissonScoredSortedSet.firstScoreAsync()
RFuture<Long>	RedissonTimeSeries.firstTimestampAsync()
RFuture<Void>	RedissonKeys.flushallAsync()
RFuture<Void>	RedissonKeys.flushallParallelAsync()
RFuture<Void>	RedissonFuction.flushAsync()
RFuture<Void>	RedissonKeys.flushdbAsync()
RFuture<Void>	RedissonKeys.flushdbParallelAsync()
RFuture<Boolean>	RedissonFairLock.forceUnlockAsync()
RFuture<Boolean>	RedissonLock.forceUnlockAsync()
RFuture<Boolean>	RedissonMultiLock.forceUnlockAsync()
RFuture<Boolean>	RedissonReadLock.forceUnlockAsync()
RFuture<Boolean>	RedissonSpinLock.forceUnlockAsync()
RFuture<Boolean>	RedissonWriteLock.forceUnlockAsync()
RFuture<Collection<V>>	RedissonListMultimap.getAllAsync(K key)
RFuture<Collection<V>>	RedissonListMultimapCache.getAllAsync(K key)
RFuture<Map<K,V>>	RedissonLocalCachedMap.getAllAsync(Set<K> keys)
RFuture<Map<K,V>>	RedissonMap.getAllAsync(Set<K> keys)
RFuture<Collection<V>>	RedissonSetMultimap.getAllAsync(K key)
RFuture<Collection<V>>	RedissonSetMultimapCache.getAllAsync(K key)
RFuture<Map<K,V>>	RedissonMap.getAllOperationAsync(Set<K> keys)
RFuture<Map<K,V>>	RedissonMapCache.getAllOperationAsync(Set<K> keys)
RFuture<Double>	RedissonAtomicDouble.getAndAddAsync(double delta)
RFuture<Long>	RedissonAtomicLong.getAndAddAsync(long delta)
RFuture<V>	RedissonBucket.getAndClearExpireAsync()
RFuture<V>	RedissonJsonBucket.getAndClearExpireAsync()
RFuture<Double>	RedissonAtomicDouble.getAndDecrementAsync()
RFuture<Long>	RedissonAtomicLong.getAndDecrementAsync()
RFuture<Double>	RedissonAtomicDouble.getAndDeleteAsync()
RFuture<Long>	RedissonAtomicLong.getAndDeleteAsync()
protected abstract RFuture<T>	RedissonBaseAdder.getAndDeleteAsync(String id)
RFuture<V>	RedissonBucket.getAndDeleteAsync()
protected RFuture<Double>	RedissonDoubleAdder.getAndDeleteAsync(String id)
RFuture<V>	RedissonJsonBucket.getAndDeleteAsync()
protected RFuture<Long>	RedissonLongAdder.getAndDeleteAsync(String id)
RFuture<V>	RedissonBucket.getAndExpireAsync(Duration duration)
RFuture<V>	RedissonBucket.getAndExpireAsync(Instant time)
RFuture<V>	RedissonJsonBucket.getAndExpireAsync(Duration duration)
RFuture<V>	RedissonJsonBucket.getAndExpireAsync(Instant time)
RFuture<Double>	RedissonAtomicDouble.getAndIncrementAsync()
RFuture<Long>	RedissonAtomicLong.getAndIncrementAsync()
RFuture<V>	RedissonTimeSeries.getAndRemoveAsync(long timestamp)
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.getAndRemoveEntryAsync(long timestamp)
RFuture<Double>	RedissonAtomicDouble.getAndSetAsync(double newValue)
RFuture<Long>	RedissonAtomicLong.getAndSetAsync(long newValue)
RFuture<V>	RedissonBucket.getAndSetAsync(V newValue)
RFuture<V>	RedissonBucket.getAndSetAsync(V value, long timeToLive, TimeUnit timeUnit)
<T> RFuture<T>	RedissonJsonBucket.getAndSetAsync(JsonCodec<T> codec, String path, Object newValue)
RFuture<V>	RedissonJsonBucket.getAndSetAsync(V newValue)
RFuture<V>	RedissonJsonBucket.getAndSetAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Double>	RedissonAtomicDouble.getAsync()
RFuture<Long>	RedissonAtomicLong.getAsync()
RFuture<Boolean>	RedissonBitSet.getAsync(long bitIndex)
RFuture<V>	RedissonBucket.getAsync()
<V> RFuture<Map<String,V>>	RedissonBuckets.getAsync(String... keys)
RFuture<V>	RedissonJsonBucket.getAsync()
<T> RFuture<T>	RedissonJsonBucket.getAsync(JsonCodec<T> codec, String... paths)
RFuture<V>	RedissonList.getAsync(int index)
RFuture<List<V>>	RedissonList.getAsync(int... indexes)
RFuture<V>	RedissonListMultimapValues.getAsync(int index)
RFuture<List<V>>	RedissonListMultimapValues.getAsync(int... indexes)
RFuture<V>	RedissonLocalCachedMap.getAsync(Object key)
RFuture<V>	RedissonMap.getAsync(K key)
RFuture<V>	RedissonSubList.getAsync(int index)
RFuture<V>	RedissonTimeSeries.getAsync(long timestamp)
RFuture<Byte>	RedissonBitSet.getByteAsync(long offset)
RFuture<RateLimiterConfig>	RedissonRateLimiter.getConfigAsync()
RFuture<Long>	RedissonCountDownLatch.getCountAsync()
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.getEntryAsync(long timestamp)
RFuture<String>	RedissonRemoteService.Entry.getFuture()
RFuture<Integer>	RedissonBaseLock.getHoldCountAsync()
RFuture<Integer>	RedissonMultiLock.getHoldCountAsync()
RFuture<Long>	RedissonObject.getIdleTimeAsync()
RFuture<StreamInfo<K,V>>	RedissonStream.getInfoAsync()
RFuture<Integer>	RedissonBitSet.getIntegerAsync(long offset)
RFuture<List<String>>	RedissonJsonBucket.getKeysAsync()
RFuture<List<String>>	RedissonJsonBucket.getKeysAsync(String path)
RFuture<List<List<String>>>	RedissonJsonBucket.getKeysMultiAsync(String path)
RFuture<V>	RedissonDeque.getLastAsync()
RFuture<V>	RedissonPriorityDeque.getLastAsync()
RFuture<Long>	RedissonBitSet.getLongAsync(long offset)
RFuture<V>	RedissonMap.getOperationAsync(K key)
RFuture<V>	RedissonMapCache.getOperationAsync(K key)
RFuture<PendingResult>	RedissonStream.getPendingInfoAsync(String groupName)
RFuture<Integer>	RedissonRemoteService.getPendingInvocationsAsync(Class<?> remoteInterface)
RFuture<List<Double>>	RedissonScoredSortedSet.getScoreAsync(Collection<V> elements)
RFuture<Double>	RedissonScoredSortedSet.getScoreAsync(V o)
RFuture<Short>	RedissonBitSet.getShortAsync(long offset)
RFuture<Long>	RedissonBitSet.getSignedAsync(int size, long offset)
RFuture<Integer>	RedissonKeys.getSlotAsync(String key)
protected RFuture<RemoteServiceRequest>	RedissonRemoteService.getTask(String requestId, RMap<String,RemoteServiceRequest> tasks)
RFuture<Integer>	RedissonExecutorService.getTaskCountAsync()
RFuture<Set<String>>	RedissonExecutorService.getTaskIdsAsync()
RFuture<JsonType>	RedissonJsonBucket.getTypeAsync()
RFuture<JsonType>	RedissonJsonBucket.getTypeAsync(String path)
RFuture<RType>	RedissonKeys.getTypeAsync(String key)
RFuture<Long>	RedissonBitSet.getUnsignedAsync(int size, long offset)
RFuture<V>	RedissonTransferQueue.getValueAsync(int index)
RFuture<V>	RedissonMapCache.getWithTTLOnlyAsync(K key)
RFuture<Map<V,String>>	RedissonGeo.hashAsync(V... members)
RFuture<Boolean>	RedissonExecutorService.hasTaskAsync(String taskId)
RFuture<Double>	RedissonAtomicDouble.incrementAndGetAsync()
RFuture<Long>	RedissonAtomicLong.incrementAndGetAsync()
<T extends Number> RFuture<T>	RedissonJsonBucket.incrementAndGetAsync(String path, T delta)
RFuture<Byte>	RedissonBitSet.incrementAndGetByteAsync(long offset, byte increment)
RFuture<Integer>	RedissonBitSet.incrementAndGetIntegerAsync(long offset, int increment)
RFuture<Long>	RedissonBitSet.incrementAndGetLongAsync(long offset, long increment)
<T extends Number> RFuture<List<T>>	RedissonJsonBucket.incrementAndGetMultiAsync(String path, T delta)
RFuture<Short>	RedissonBitSet.incrementAndGetShortAsync(long offset, short increment)
RFuture<Long>	RedissonBitSet.incrementAndGetSignedAsync(int size, long offset, long increment)
RFuture<Long>	RedissonBitSet.incrementAndGetUnsignedAsync(int size, long offset, long increment)
RFuture<Integer>	RedissonList.indexOfAsync(Object o)
<R> RFuture<R>	RedissonList.indexOfAsync(Object o, Convertor<R> convertor)
RFuture<Integer>	RedissonListMultimapValues.indexOfAsync(Object o)
<R> RFuture<R>	RedissonSubList.indexOfAsync(Object o, Convertor<R> convertor)
RFuture<Integer>	RedissonScoredSortedSet.intersectionAsync(String... names)
RFuture<Integer>	RedissonScoredSortedSet.intersectionAsync(Map<String,Double> nameWithWeight)
RFuture<Integer>	RedissonScoredSortedSet.intersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)
RFuture<Integer>	RedissonScoredSortedSet.intersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
RFuture<Integer>	RedissonSet.intersectionAsync(String... names)
RFuture<Integer>	RedissonSetMultimapValues.intersectionAsync(String... names)
<V> RFuture<Void>	RedissonTransferQueue.TransferQueueServiceAsync.invoke(V value)
RFuture<Boolean>	RedissonBloomFilter.isExistsAsync()
RFuture<Boolean>	RedissonObject.isExistsAsync()
RFuture<Boolean>	RedissonBaseLock.isLockedAsync()
RFuture<Boolean>	RedissonMultiLock.isLockedAsync()
RFuture<Integer>	RedissonMultimap.keySizeAsync()
RFuture<Void>	RedissonFuction.killAsync()
RFuture<V>	RedissonScoredSortedSet.lastAsync()
RFuture<V>	RedissonTimeSeries.lastAsync()
RFuture<Collection<V>>	RedissonTimeSeries.lastAsync(int count)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.lastEntriesAsync(int count)
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.lastEntryAsync()
RFuture<Integer>	RedissonList.lastIndexOfAsync(Object o)
<R> RFuture<R>	RedissonList.lastIndexOfAsync(Object o, Convertor<R> convertor)
RFuture<Integer>	RedissonListMultimapValues.lastIndexOfAsync(Object o)
RFuture<Integer>	RedissonSubList.lastIndexOfAsync(Object o)
RFuture<Double>	RedissonScoredSortedSet.lastScoreAsync()
RFuture<Long>	RedissonTimeSeries.lastTimestampAsync()
RFuture<Long>	RedissonBitSet.lengthAsync()
RFuture<List<FunctionLibrary>>	RedissonFuction.listAsync()
RFuture<List<FunctionLibrary>>	RedissonFuction.listAsync(String namePattern)
RFuture<List<StreamConsumer>>	RedissonStream.listConsumersAsync(String groupName)
RFuture<List<StreamGroup>>	RedissonStream.listGroupsAsync()
RFuture<List<PendingEntry>>	RedissonStream.listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count)
RFuture<List<PendingEntry>>	RedissonStream.listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)
RFuture<List<PendingEntry>>	RedissonStream.listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, int count)
RFuture<List<PendingEntry>>	RedissonStream.listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)
RFuture<Void>	RedissonMap.loadAllAsync(boolean replaceExistingValues, int parallelism)
RFuture<Void>	RedissonMap.loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RFuture<Void>	RedissonFuction.loadAndReplaceAsync(String libraryName, String code)
RFuture<Void>	RedissonFuction.loadAsync(String libraryName, String code)
RFuture<Void>	RedissonLock.lockAsync()
RFuture<Void>	RedissonLock.lockAsync(long currentThreadId)
RFuture<Void>	RedissonLock.lockAsync(long leaseTime, TimeUnit unit)
RFuture<Void>	RedissonLock.lockAsync(long leaseTime, TimeUnit unit, long currentThreadId)
RFuture<Void>	RedissonMultiLock.lockAsync()
RFuture<Void>	RedissonMultiLock.lockAsync(long threadId)
RFuture<Void>	RedissonMultiLock.lockAsync(long leaseTime, TimeUnit unit)
RFuture<Void>	RedissonMultiLock.lockAsync(long leaseTime, TimeUnit unit, long threadId)
RFuture<Void>	RedissonSpinLock.lockAsync()
RFuture<Void>	RedissonSpinLock.lockAsync(long currentThreadId)
RFuture<Void>	RedissonSpinLock.lockAsync(long leaseTime, TimeUnit unit)
RFuture<Void>	RedissonSpinLock.lockAsync(long leaseTime, TimeUnit unit, long currentThreadId)
protected final <M> RFuture<M>	RedissonMap.mapWriterFuture(RFuture<M> future, MapWriterTask task)
protected final <M> RFuture<M>	RedissonMap.mapWriterFuture(RFuture<M> future, MapWriterTask task, Function<M,Boolean> condition)
RFuture<V>	RedissonMap.mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
RFuture<Void>	RedissonHyperLogLog.mergeWithAsync(String... otherLogNames)
RFuture<Void>	RedissonKeys.migrateAsync(String name, String host, int port, int database, long timeout)
RFuture<Void>	RedissonObject.migrateAsync(String host, int port, int database, long timeout)
RFuture<V>	RedissonBlockingDeque.moveAsync(Duration timeout, DequeMoveArgs args)
RFuture<V>	RedissonDeque.moveAsync(DequeMoveArgs args)
RFuture<Boolean>	RedissonKeys.moveAsync(String name, int database)
RFuture<Boolean>	RedissonObject.moveAsync(int database)
RFuture<V>	RedissonPriorityBlockingDeque.moveAsync(Duration timeout, DequeMoveArgs args)
RFuture<V>	RedissonPriorityDeque.moveAsync(DequeMoveArgs args)
RFuture<Boolean>	RedissonSet.moveAsync(String destination, V member)
RFuture<Boolean>	RedissonSetMultimapValues.moveAsync(String destination, V member)
RFuture<Long>	RedissonIdGenerator.nextIdAsync()
RFuture<Void>	RedissonBitSet.notAsync()
RFuture<Boolean>	RedissonBoundedBlockingQueue.offerAsync(V e)
RFuture<Boolean>	RedissonBoundedBlockingQueue.offerAsync(V e, long timeout, TimeUnit unit)
RFuture<Boolean>	RedissonDelayedQueue.offerAsync(V e)
RFuture<Void>	RedissonDelayedQueue.offerAsync(V e, long delay, TimeUnit timeUnit)
RFuture<Boolean>	RedissonPriorityBlockingDeque.offerAsync(V e)
RFuture<Boolean>	RedissonPriorityBlockingQueue.offerAsync(V e)
RFuture<Boolean>	RedissonPriorityQueue.offerAsync(V e)
RFuture<Boolean>	RedissonQueue.offerAsync(V e)
RFuture<Boolean>	RedissonTransferQueue.offerAsync(V e)
RFuture<Boolean>	RedissonDeque.offerFirstAsync(V e)
RFuture<Boolean>	RedissonPriorityDeque.offerFirstAsync(V e)
RFuture<Boolean>	RedissonDeque.offerLastAsync(V e)
RFuture<Boolean>	RedissonPriorityDeque.offerLastAsync(V e)
RFuture<Void>	RedissonBitSet.orAsync(String... bitSetNames)
RFuture<V>	RedissonDelayedQueue.peekAsync()
RFuture<V>	RedissonPriorityQueue.peekAsync()
RFuture<V>	RedissonQueue.peekAsync()
RFuture<V>	RedissonTransferQueue.peekAsync()
RFuture<V>	RedissonDeque.peekFirstAsync()
RFuture<V>	RedissonPriorityDeque.peekFirstAsync()
RFuture<V>	RedissonDeque.peekLastAsync()
RFuture<V>	RedissonPriorityDeque.peekLastAsync()
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.pendingRangeAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.pendingRangeAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.pendingRangeAsync(String groupName, StreamMessageId startId, StreamMessageId endId, int count)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.pendingRangeAsync(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)
RFuture<V>	RedissonBlockingDeque.pollAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonBlockingQueue.pollAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonBoundedBlockingQueue.pollAsync()
RFuture<V>	RedissonBoundedBlockingQueue.pollAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonDelayedQueue.pollAsync()
RFuture<List<V>>	RedissonDelayedQueue.pollAsync(int limit)
RFuture<List<V>>	RedissonPriorityBlockingDeque.pollAsync(int limit)
RFuture<V>	RedissonPriorityBlockingDeque.pollAsync(long timeout, TimeUnit unit)
RFuture<List<V>>	RedissonPriorityBlockingQueue.pollAsync(int limit)
RFuture<V>	RedissonPriorityBlockingQueue.pollAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonPriorityQueue.pollAsync()
RFuture<List<V>>	RedissonPriorityQueue.pollAsync(int limit)
RFuture<V>	RedissonQueue.pollAsync()
RFuture<List<V>>	RedissonQueue.pollAsync(int limit)
RFuture<V>	RedissonTransferQueue.pollAsync()
RFuture<List<V>>	RedissonTransferQueue.pollAsync(int limit)
RFuture<V>	RedissonTransferQueue.pollAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonBlockingDeque.pollFirstAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonDeque.pollFirstAsync()
RFuture<List<V>>	RedissonDeque.pollFirstAsync(int limit)
RFuture<List<V>>	RedissonPriorityBlockingDeque.pollFirstAsync(int limit)
RFuture<V>	RedissonPriorityBlockingDeque.pollFirstAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonPriorityDeque.pollFirstAsync()
RFuture<List<V>>	RedissonPriorityDeque.pollFirstAsync(int limit)
RFuture<V>	RedissonScoredSortedSet.pollFirstAsync()
RFuture<Collection<V>>	RedissonScoredSortedSet.pollFirstAsync(int count)
RFuture<V>	RedissonScoredSortedSet.pollFirstAsync(long timeout, TimeUnit unit)
RFuture<List<V>>	RedissonScoredSortedSet.pollFirstAsync(Duration duration, int count)
RFuture<V>	RedissonTimeSeries.pollFirstAsync()
RFuture<Collection<V>>	RedissonTimeSeries.pollFirstAsync(int count)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.pollFirstEntriesAsync(int count)
RFuture<Map<String,Map<V,Double>>>	RedissonScoredSortedSet.pollFirstEntriesFromAnyAsync(int count, String... queueNames)
RFuture<Map<String,Map<V,Double>>>	RedissonScoredSortedSet.pollFirstEntriesFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.pollFirstEntryAsync()
RFuture<V>	RedissonBlockingDeque.pollFirstFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBlockingDeque.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBlockingQueue.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBoundedBlockingQueue.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<V>	RedissonPriorityBlockingDeque.pollFirstFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonPriorityBlockingDeque.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonPriorityBlockingQueue.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<List<V>>	RedissonScoredSortedSet.pollFirstFromAnyAsync(int count, String... queueNames)
RFuture<V>	RedissonScoredSortedSet.pollFirstFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<List<V>>	RedissonScoredSortedSet.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonTransferQueue.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<V>	RedissonBlockingDeque.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonBlockingQueue.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonBoundedBlockingQueue.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonPriorityBlockingDeque.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonPriorityBlockingQueue.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonTransferQueue.pollFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<V>	RedissonBlockingDeque.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonBlockingQueue.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonBoundedBlockingQueue.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonDelayedQueue.pollLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonPriorityBlockingDeque.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonPriorityBlockingQueue.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonPriorityQueue.pollLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonQueue.pollLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonTransferQueue.pollLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonTransferQueue.pollLastAndOfferFirstToAsync(String queueName, long timeout, TimeUnit unit)
RFuture<V>	RedissonBlockingDeque.pollLastAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonDeque.pollLastAsync()
RFuture<List<V>>	RedissonDeque.pollLastAsync(int limit)
RFuture<List<V>>	RedissonPriorityBlockingDeque.pollLastAsync(int limit)
RFuture<V>	RedissonPriorityBlockingDeque.pollLastAsync(long timeout, TimeUnit unit)
RFuture<V>	RedissonPriorityDeque.pollLastAsync()
RFuture<List<V>>	RedissonPriorityDeque.pollLastAsync(int limit)
RFuture<V>	RedissonScoredSortedSet.pollLastAsync()
RFuture<Collection<V>>	RedissonScoredSortedSet.pollLastAsync(int count)
RFuture<V>	RedissonScoredSortedSet.pollLastAsync(long timeout, TimeUnit unit)
RFuture<List<V>>	RedissonScoredSortedSet.pollLastAsync(Duration duration, int count)
RFuture<V>	RedissonTimeSeries.pollLastAsync()
RFuture<Collection<V>>	RedissonTimeSeries.pollLastAsync(int count)
RFuture<Collection<TimeSeriesEntry<V,L>>>	RedissonTimeSeries.pollLastEntriesAsync(int count)
RFuture<Map<String,Map<V,Double>>>	RedissonScoredSortedSet.pollLastEntriesFromAnyAsync(int count, String... queueNames)
RFuture<Map<String,Map<V,Double>>>	RedissonScoredSortedSet.pollLastEntriesFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<TimeSeriesEntry<V,L>>	RedissonTimeSeries.pollLastEntryAsync()
RFuture<V>	RedissonBlockingDeque.pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBlockingDeque.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBlockingQueue.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonBoundedBlockingQueue.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<V>	RedissonPriorityBlockingDeque.pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonPriorityBlockingDeque.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonPriorityBlockingQueue.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<List<V>>	RedissonScoredSortedSet.pollLastFromAnyAsync(int count, String... queueNames)
RFuture<V>	RedissonScoredSortedSet.pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)
RFuture<List<V>>	RedissonScoredSortedSet.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<Map<String,List<V>>>	RedissonTransferQueue.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)
RFuture<V>	RedissonDeque.popAsync()
RFuture<V>	RedissonPriorityDeque.popAsync()
RFuture<Map<V,GeoPosition>>	RedissonGeo.posAsync(V... members)
RFuture<Long>	RedissonReliableTopic.publishAsync(Object message)
RFuture<Long>	RedissonShardedTopic.publishAsync(Object message)
RFuture<Long>	RedissonTopic.publishAsync(Object message)
RFuture<Void>	RedissonDeque.pushAsync(V e)
RFuture<Void>	RedissonPriorityDeque.pushAsync(V e)
protected abstract RFuture<Long>	QueueTransferTask.pushTaskAsync()
RFuture<Boolean>	RedissonListMultimap.putAllAsync(K key, Iterable<? extends V> values)
final RFuture<Void>	RedissonMap.putAllAsync(Map<? extends K,? extends V> map)
RFuture<Void>	RedissonMap.putAllAsync(Map<? extends K,? extends V> map, int batchSize)
RFuture<Void>	RedissonMapCache.putAllAsync(Map<? extends K,? extends V> map, long ttl, TimeUnit ttlUnit)
RFuture<Boolean>	RedissonSetMultimap.putAllAsync(K key, Iterable<? extends V> values)
protected RFuture<Void>	RedissonLocalCachedMap.putAllOperationAsync(Map<? extends K,? extends V> map)
protected RFuture<Void>	RedissonMap.putAllOperationAsync(Map<? extends K,? extends V> map)
protected RFuture<Void>	RedissonMapCache.putAllOperationAsync(Map<? extends K,? extends V> map)
RFuture<Void>	RedissonBlockingDeque.putAsync(V e)
RFuture<Void>	RedissonBlockingQueue.putAsync(V e)
RFuture<Void>	RedissonBoundedBlockingQueue.putAsync(V e)
RFuture<Boolean>	RedissonListMultimap.putAsync(K key, V value)
RFuture<V>	RedissonMap.putAsync(K key, V value)
RFuture<V>	RedissonMapCache.putAsync(K key, V value, long ttl, TimeUnit ttlUnit)
RFuture<V>	RedissonMapCache.putAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<Void>	RedissonPriorityBlockingDeque.putAsync(V e)
RFuture<Void>	RedissonPriorityBlockingQueue.putAsync(V e)
RFuture<Boolean>	RedissonSetMultimap.putAsync(K key, V value)
RFuture<Void>	RedissonTransferQueue.putAsync(V value)
RFuture<Void>	RedissonBlockingDeque.putFirstAsync(V e)
RFuture<Void>	RedissonPriorityBlockingDeque.putFirstAsync(V e)
RFuture<V>	RedissonLocalCachedMap.putIfAbsentAsync(K key, V value)
RFuture<V>	RedissonMap.putIfAbsentAsync(K key, V value)
RFuture<V>	RedissonMapCache.putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit)
RFuture<V>	RedissonMapCache.putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<V>	RedissonMap.putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	RedissonMapCache.putIfAbsentOperationAsync(K key, V value)
RFuture<V>	RedissonLocalCachedMap.putIfExistsAsync(K key, V value)
RFuture<V>	RedissonMap.putIfExistsAsync(K key, V value)
protected RFuture<V>	RedissonMap.putIfExistsOperationAsync(K key, V value)
protected RFuture<V>	RedissonMapCache.putIfExistsOperationAsync(K key, V value)
RFuture<Void>	RedissonBlockingDeque.putLastAsync(V e)
RFuture<Void>	RedissonPriorityBlockingDeque.putLastAsync(V e)
protected RFuture<V>	RedissonLocalCachedMap.putOperationAsync(K key, V value)
protected RFuture<V>	RedissonMap.putOperationAsync(K key, V value)
protected RFuture<V>	RedissonMapCache.putOperationAsync(K key, V value)
protected RFuture<V>	RedissonMapCache.putOperationAsync(K key, V value, long ttlTimeout, long maxIdleTimeout, long maxIdleDelta, long ttlTimeoutDelta)
RFuture<List<V>>	RedissonGeo.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<List<V>>	RedissonGeo.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<List<V>>	RedissonGeo.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<List<V>>	RedissonGeo.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<List<V>>	RedissonGeo.radiusAsync(V member, double radius, GeoUnit geoUnit)
RFuture<List<V>>	RedissonGeo.radiusAsync(V member, double radius, GeoUnit geoUnit, int count)
RFuture<List<V>>	RedissonGeo.radiusAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<List<V>>	RedissonGeo.radiusAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RedissonGeo.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RedissonGeo.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,Double>>	RedissonGeo.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,GeoPosition>>	RedissonGeo.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<V>	RedissonScoredSortedSet.randomAsync()
RFuture<Collection<V>>	RedissonScoredSortedSet.randomAsync(int count)
RFuture<V>	RedissonSet.randomAsync()
RFuture<Set<V>>	RedissonSet.randomAsync(int count)
RFuture<V>	RedissonSetMultimapValues.randomAsync()
RFuture<Set<V>>	RedissonSetMultimapValues.randomAsync(int count)
RFuture<Map<K,V>>	RedissonMap.randomEntriesAsync(int count)
RFuture<Map<K,V>>	RedissonMapCache.randomEntriesAsync(int count)
RFuture<Map<V,Double>>	RedissonScoredSortedSet.randomEntriesAsync(int count)
RFuture<String>	RedissonKeys.randomKeyAsync()
RFuture<Set<K>>	RedissonMap.randomKeysAsync(int count)
RFuture<Set<K>>	RedissonMapCache.randomKeysAsync(int count)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeAsync(int startIndex, int endIndex)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count)
RFuture<List<V>>	RedissonList.rangeAsync(int toIndex)
RFuture<List<V>>	RedissonList.rangeAsync(int fromIndex, int toIndex)
RFuture<List<V>>	RedissonListMultimapValues.rangeAsync(int toIndex)
RFuture<List<V>>	RedissonListMultimapValues.rangeAsync(int fromIndex, int toIndex)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.rangeAsync(int count, StreamMessageId startId, StreamMessageId endId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.rangeAsync(StreamMessageId startId, StreamMessageId endId)
RFuture<Collection<V>>	RedissonTimeSeries.rangeAsync(long startTimestamp, long endTimestamp)
RFuture<Collection<V>>	RedissonTimeSeries.rangeAsync(long startTimestamp, long endTimestamp, int limit)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeHeadAsync(String toElement, boolean toInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeHeadAsync(String toElement, boolean toInclusive, int offset, int count)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeHeadReversedAsync(String toElement, boolean toInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeHeadReversedAsync(String toElement, boolean toInclusive, int offset, int count)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeReversedAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeReversedAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.rangeReversedAsync(int count, StreamMessageId startId, StreamMessageId endId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.rangeReversedAsync(StreamMessageId startId, StreamMessageId endId)
RFuture<Collection<V>>	RedissonTimeSeries.rangeReversedAsync(long startTimestamp, long endTimestamp)
RFuture<Collection<V>>	RedissonTimeSeries.rangeReversedAsync(long startTimestamp, long endTimestamp, int limit)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeTailAsync(String fromElement, boolean fromInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeTailAsync(String fromElement, boolean fromInclusive, int offset, int count)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeTailReversedAsync(String fromElement, boolean fromInclusive)
RFuture<Collection<String>>	RedissonLexSortedSet.rangeTailReversedAsync(String fromElement, boolean fromInclusive, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Integer>	RedissonScoredSortedSet.rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.rangeToAsync(String destName, int startIndex, int endIndex)
RFuture<Integer>	RedissonScoredSortedSet.rankAsync(V o)
RFuture<List<V>>	RedissonDelayedQueue.readAllAsync()
RFuture<List<V>>	RedissonList.readAllAsync()
RFuture<List<V>>	RedissonListMultimapValues.readAllAsync()
RFuture<Collection<V>>	RedissonScoredSortedSet.readAllAsync()
RFuture<Set<V>>	RedissonSet.readAllAsync()
RFuture<Set<V>>	RedissonSetCache.readAllAsync()
RFuture<Set<V>>	RedissonSetMultimapValues.readAllAsync()
RFuture<Collection<V>>	RedissonSortedSet.readAllAsync()
RFuture<List<V>>	RedissonSubList.readAllAsync()
RFuture<List<V>>	RedissonTransferQueue.readAllAsync()
RFuture<Set<Map.Entry<K,V>>>	RedissonLocalCachedMap.readAllEntrySetAsync()
RFuture<Set<Map.Entry<K,V>>>	RedissonMap.readAllEntrySetAsync()
RFuture<Set<Map.Entry<K,V>>>	RedissonMapCache.readAllEntrySetAsync()
RFuture<Set<K>>	RedissonMap.readAllKeySetAsync()
RFuture<Set<K>>	RedissonMapCache.readAllKeySetAsync()
RFuture<Set<K>>	RedissonMultimap.readAllKeySetAsync()
RFuture<Map<K,V>>	RedissonLocalCachedMap.readAllMapAsync()
RFuture<Map<K,V>>	RedissonMap.readAllMapAsync()
RFuture<Map<K,V>>	RedissonMapCache.readAllMapAsync()
RFuture<Collection<V>>	RedissonLocalCachedMap.readAllValuesAsync()
RFuture<Collection<V>>	RedissonMap.readAllValuesAsync()
RFuture<Collection<V>>	RedissonMapCache.readAllValuesAsync()
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readAsync(int count, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(int count, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readAsync(long timeout, TimeUnit unit, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(StreamMultiReadArgs args)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readAsync(StreamReadArgs args)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readAsync(StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readAsync(StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Collection<V>>	RedissonScoredSortedSet.readDiffAsync(String... names)
RFuture<Set<V>>	RedissonSet.readDiffAsync(String... names)
RFuture<Set<V>>	RedissonSetMultimapValues.readDiffAsync(String... names)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamMultiReadGroupArgs args)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamReadGroupArgs args)
RFuture<Map<StreamMessageId,Map<K,V>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamMessageId... ids)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RedissonStream.readGroupAsync(String groupName, String consumerName, StreamMessageId id, Map<String,StreamMessageId> keyToId)
RFuture<Collection<V>>	RedissonScoredSortedSet.readIntersectionAsync(String... names)
RFuture<Collection<V>>	RedissonScoredSortedSet.readIntersectionAsync(Map<String,Double> nameWithWeight)
RFuture<Collection<V>>	RedissonScoredSortedSet.readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)
RFuture<Collection<V>>	RedissonScoredSortedSet.readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
RFuture<Set<V>>	RedissonSet.readIntersectionAsync(String... names)
RFuture<Set<V>>	RedissonSetMultimapValues.readIntersectionAsync(String... names)
<T> RFuture<Collection<T>>	RedissonList.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonList.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonList.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<List<V>>	RedissonList.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonList.readSortAlphaAsync(SortOrder order)
RFuture<List<V>>	RedissonList.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonListMultimapValues.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonListMultimapValues.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonListMultimapValues.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<List<V>>	RedissonListMultimapValues.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonListMultimapValues.readSortAlphaAsync(SortOrder order)
RFuture<List<V>>	RedissonListMultimapValues.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonScoredSortedSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonScoredSortedSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAlphaAsync(SortOrder order)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSet.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonSet.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSet.readSortAlphaAsync(SortOrder order)
RFuture<Set<V>>	RedissonSet.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonSetMultimapValues.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonSetMultimapValues.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAlphaAsync(SortOrder order)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonList.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonList.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonList.readSortAsync(String byPattern, SortOrder order)
RFuture<List<V>>	RedissonList.readSortAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonList.readSortAsync(SortOrder order)
RFuture<List<V>>	RedissonList.readSortAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonListMultimapValues.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonListMultimapValues.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonListMultimapValues.readSortAsync(String byPattern, SortOrder order)
RFuture<List<V>>	RedissonListMultimapValues.readSortAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<List<V>>	RedissonListMultimapValues.readSortAsync(SortOrder order)
RFuture<List<V>>	RedissonListMultimapValues.readSortAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonScoredSortedSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonScoredSortedSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAsync(SortOrder order)
RFuture<Set<V>>	RedissonScoredSortedSet.readSortAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSet.readSortAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonSet.readSortAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSet.readSortAsync(SortOrder order)
RFuture<Set<V>>	RedissonSet.readSortAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonSetMultimapValues.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonSetMultimapValues.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAsync(SortOrder order)
RFuture<Set<V>>	RedissonSetMultimapValues.readSortAsync(SortOrder order, int offset, int count)
RFuture<Collection<V>>	RedissonScoredSortedSet.readUnionAsync(String... names)
RFuture<Collection<V>>	RedissonScoredSortedSet.readUnionAsync(Map<String,Double> nameWithWeight)
RFuture<Collection<V>>	RedissonScoredSortedSet.readUnionAsync(RScoredSortedSet.Aggregate aggregate, String... names)
RFuture<Collection<V>>	RedissonScoredSortedSet.readUnionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
RFuture<Set<V>>	RedissonSet.readUnionAsync(String... names)
RFuture<Set<V>>	RedissonSetMultimapValues.readUnionAsync(String... names)
RFuture<Void>	RedissonPermitExpirableSemaphore.releaseAsync(String permitId)
RFuture<Void>	RedissonSemaphore.releaseAsync()
RFuture<Void>	RedissonSemaphore.releaseAsync(int permits)
RFuture<Integer>	RedissonRingBuffer.remainingCapacityAsync()
RFuture<Long>	RedissonKeys.remainTimeToLiveAsync(String name)
RFuture<Long>	RedissonListMultimapValues.remainTimeToLiveAsync()
RFuture<Long>	RedissonMapCache.remainTimeToLiveAsync(K key)
RFuture<Long>	RedissonMultiLock.remainTimeToLiveAsync()
RFuture<Long>	RedissonSetMultimapValues.remainTimeToLiveAsync()
RFuture<Boolean>	RedissonBoundedBlockingQueue.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonDelayedQueue.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonList.removeAllAsync(Collection<?> c)
RFuture<Collection<V>>	RedissonListMultimap.removeAllAsync(Object key)
RFuture<Collection<V>>	RedissonListMultimapCache.removeAllAsync(Object key)
RFuture<Boolean>	RedissonListMultimapValues.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonScoredSortedSet.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSet.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSetCache.removeAllAsync(Collection<?> c)
RFuture<Collection<V>>	RedissonSetMultimap.removeAllAsync(Object key)
RFuture<Collection<V>>	RedissonSetMultimapCache.removeAllAsync(Object key)
RFuture<Boolean>	RedissonSetMultimapValues.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSubList.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransferQueue.removeAllAsync(Collection<?> c)
RFuture<Integer>	RedissonSet.removeAllCountedAsync(Collection<? extends V> c)
RFuture<Integer>	RedissonSetMultimapValues.removeAllCountedAsync(Collection<? extends V> c)
RFuture<Void>	RedissonPatternTopic.removeAllListenersAsync()
RFuture<Void>	RedissonReliableTopic.removeAllListenersAsync()
RFuture<Void>	RedissonShardedTopic.removeAllListenersAsync()
RFuture<Void>	RedissonTopic.removeAllListenersAsync()
RFuture<Boolean>	RedissonBoundedBlockingQueue.removeAsync(Object o)
RFuture<Boolean>	RedissonDelayedQueue.removeAsync(Object o)
protected RFuture<Boolean>	RedissonDelayedQueue.removeAsync(Object o, int count)
RFuture<V>	RedissonList.removeAsync(int index)
RFuture<Boolean>	RedissonList.removeAsync(Object o)
RFuture<Boolean>	RedissonList.removeAsync(Object o, int count)
RFuture<Boolean>	RedissonListMultimap.removeAsync(Object key, Object value)
RFuture<V>	RedissonListMultimapValues.removeAsync(int index)
RFuture<Boolean>	RedissonListMultimapValues.removeAsync(Object o)
RFuture<Boolean>	RedissonListMultimapValues.removeAsync(Object o, int count)
RFuture<Boolean>	RedissonLocalCachedMap.removeAsync(Object key, Object value)
RFuture<Boolean>	RedissonMap.removeAsync(Object key, Object value)
RFuture<V>	RedissonMap.removeAsync(K key)
RFuture<Boolean>	RedissonPriorityDeque.removeAsync(Object o, int count)
RFuture<Boolean>	RedissonScoredSortedSet.removeAsync(Object object)
RFuture<Boolean>	RedissonSet.removeAsync(Object o)
RFuture<Boolean>	RedissonSetCache.removeAsync(Object o)
RFuture<Boolean>	RedissonSetMultimap.removeAsync(Object key, Object value)
RFuture<Boolean>	RedissonSetMultimapValues.removeAsync(Object o)
RFuture<Boolean>	RedissonSortedSet.removeAsync(Object value)
RFuture<Long>	RedissonStream.removeAsync(StreamMessageId... ids)
RFuture<Boolean>	RedissonSubList.removeAsync(Object o)
RFuture<Boolean>	RedissonTimeSeries.removeAsync(long timestamp)
RFuture<Boolean>	RedissonTransferQueue.removeAsync(Object o)
RFuture<Long>	RedissonStream.removeConsumerAsync(String groupName, String consumerName)
RFuture<V>	RedissonDeque.removeFirstAsync()
RFuture<V>	RedissonPriorityDeque.removeFirstAsync()
RFuture<Boolean>	RedissonDeque.removeFirstOccurrenceAsync(Object o)
RFuture<Boolean>	RedissonPriorityDeque.removeFirstOccurrenceAsync(Object o)
RFuture<Void>	RedissonStream.removeGroupAsync(String groupName)
RFuture<V>	RedissonDeque.removeLastAsync()
RFuture<V>	RedissonPriorityDeque.removeLastAsync()
RFuture<Boolean>	RedissonDeque.removeLastOccurrenceAsync(Object o)
RFuture<Boolean>	RedissonPriorityDeque.removeLastOccurrenceAsync(Object o)
RFuture<Void>	RedissonBucket.removeListenerAsync(int listenerId)
RFuture<Void>	RedissonList.removeListenerAsync(int listenerId)
RFuture<Void>	RedissonObject.removeListenerAsync(int listenerId)
RFuture<Void>	RedissonPatternTopic.removeListenerAsync(int listenerId)
RFuture<Void>	RedissonReliableTopic.removeListenerAsync(String... listenerIds)
RFuture<Void>	RedissonScoredSortedSet.removeListenerAsync(int listenerId)
RFuture<Void>	RedissonShardedTopic.removeListenerAsync(Integer... listenerIds)
RFuture<Void>	RedissonShardedTopic.removeListenerAsync(MessageListener<?> listener)
RFuture<Void>	RedissonTopic.removeListenerAsync(Integer... listenerIds)
RFuture<Void>	RedissonTopic.removeListenerAsync(MessageListener<?> listener)
protected RFuture<Boolean>	RedissonLocalCachedMap.removeOperationAsync(Object key, Object value)
protected RFuture<V>	RedissonLocalCachedMap.removeOperationAsync(K key)
protected RFuture<Boolean>	RedissonMap.removeOperationAsync(Object key, Object value)
protected RFuture<V>	RedissonMap.removeOperationAsync(K key)
protected RFuture<Boolean>	RedissonMapCache.removeOperationAsync(Object key, Object value)
protected RFuture<V>	RedissonMapCache.removeOperationAsync(K key)
RFuture<V>	RedissonSet.removeRandomAsync()
RFuture<Set<V>>	RedissonSet.removeRandomAsync(int amount)
RFuture<V>	RedissonSetMultimapValues.removeRandomAsync()
RFuture<Set<V>>	RedissonSetMultimapValues.removeRandomAsync(int amount)
RFuture<Integer>	RedissonLexSortedSet.removeRangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)
RFuture<Integer>	RedissonTimeSeries.removeRangeAsync(long startTimestamp, long endTimestamp)
RFuture<Integer>	RedissonScoredSortedSet.removeRangeByRankAsync(int startIndex, int endIndex)
RFuture<Integer>	RedissonScoredSortedSet.removeRangeByScoreAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Integer>	RedissonLexSortedSet.removeRangeHeadAsync(String toElement, boolean toInclusive)
RFuture<Integer>	RedissonLexSortedSet.removeRangeTailAsync(String fromElement, boolean fromInclusive)
RFuture<Void>	RedissonBloomFilter.renameAsync(String newName)
RFuture<Void>	RedissonKeys.renameAsync(String currentName, String newName)
RFuture<Void>	RedissonListMultimapValues.renameAsync(String newName)
RFuture<Void>	RedissonMultimap.renameAsync(String newName)
RFuture<Void>	RedissonObject.renameAsync(String newName)
RFuture<Void>	RedissonSetMultimapValues.renameAsync(String newName)
RFuture<Boolean>	RedissonBloomFilter.renamenxAsync(String newName)
RFuture<Boolean>	RedissonKeys.renamenxAsync(String oldName, String newName)
RFuture<Boolean>	RedissonListMultimapValues.renamenxAsync(String newName)
RFuture<Boolean>	RedissonMultimap.renamenxAsync(String newName)
RFuture<Boolean>	RedissonObject.renamenxAsync(String newName)
RFuture<Boolean>	RedissonSetMultimapValues.renamenxAsync(String newName)
RFuture<V>	RedissonLocalCachedMap.replaceAsync(K key, V value)
RFuture<Boolean>	RedissonLocalCachedMap.replaceAsync(K key, V oldValue, V newValue)
RFuture<V>	RedissonMap.replaceAsync(K key, V value)
RFuture<Boolean>	RedissonMap.replaceAsync(K key, V oldValue, V newValue)
RFuture<Boolean>	RedissonScoredSortedSet.replaceAsync(V oldObject, V newObject)
protected RFuture<V>	RedissonLocalCachedMap.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonLocalCachedMap.replaceOperationAsync(K key, V oldValue, V newValue)
protected RFuture<V>	RedissonMap.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMap.replaceOperationAsync(K key, V oldValue, V newValue)
protected RFuture<V>	RedissonMapCache.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonMapCache.replaceOperationAsync(K key, V oldValue, V newValue)
RFuture<Collection<V>>	RedissonListMultimap.replaceValuesAsync(K key, Iterable<? extends V> values)
RFuture<Collection<V>>	RedissonSetMultimap.replaceValuesAsync(K key, Iterable<? extends V> values)
RFuture<Void>	RedissonBaseAdder.resetAsync()
RFuture<Void>	RedissonBaseAdder.resetAsync(long timeout, TimeUnit timeUnit)
RFuture<Void>	RedissonFuction.restoreAfterFlushAsync(byte[] payload)
RFuture<Void>	RedissonFuction.restoreAndReplaceAsync(byte[] payload)
RFuture<Void>	RedissonObject.restoreAndReplaceAsync(byte[] state)
RFuture<Void>	RedissonObject.restoreAndReplaceAsync(byte[] state, long timeToLive, TimeUnit timeUnit)
RFuture<Void>	RedissonFuction.restoreAsync(byte[] payload)
RFuture<Void>	RedissonObject.restoreAsync(byte[] state)
RFuture<Void>	RedissonObject.restoreAsync(byte[] state, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonDelayedQueue.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonList.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonListMultimapValues.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonScoredSortedSet.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSet.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSetCache.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSetMultimapValues.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonSubList.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransferQueue.retainAllAsync(Collection<?> c)
RFuture<Integer>	RedissonScoredSortedSet.revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Integer>	RedissonScoredSortedSet.revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.revRangeToAsync(String destName, int startIndex, int endIndex)
RFuture<List<Integer>>	RedissonScoredSortedSet.revRankAsync(Collection<V> elements)
RFuture<Integer>	RedissonScoredSortedSet.revRankAsync(V o)
RFuture<ScanResult<Object>>	RedissonKeys.scanIteratorAsync(RedisClient client, MasterSlaveEntry entry, long startPos, String pattern, int count)
RFuture<ScanResult<Object>>	RedissonKeys.scanIteratorAsync(RedisClient client, MasterSlaveEntry entry, RedisCommand<?> command, long startPos, String pattern, int count)
RFuture<ScanResult<Map.Entry<Object,Object>>>	RedissonMap.scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<ScanResult<Map.Entry<Object,Object>>>	RedissonMapCache.scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<ScanResult<Object>>	RedissonScoredSortedSet.scanIteratorAsync(RedisClient client, long startPos, String pattern, int count)
RFuture<ScanResult<Object>>	RedissonSet.scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<ScanResult<Object>>	RedissonSetCache.scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<ListScanResult<Object>>	RedissonTimeSeries.scanIteratorAsync(String name, RedisClient client, long startPos, int count)
RFuture<ScanResult<Object>>	ScanIterator.scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)
RFuture<List<Boolean>>	RedissonScript.scriptExistsAsync(String... shaDigests)
RFuture<List<Boolean>>	RedissonScript.scriptExistsAsync(String key, String... shaDigests)
RFuture<Void>	RedissonScript.scriptFlushAsync()
RFuture<Void>	RedissonScript.scriptFlushAsync(String key)
RFuture<Void>	RedissonScript.scriptKillAsync()
RFuture<Void>	RedissonScript.scriptKillAsync(String key)
RFuture<String>	RedissonScript.scriptLoadAsync(String luaScript)
RFuture<String>	RedissonScript.scriptLoadAsync(String key, String luaScript)
RFuture<List<V>>	RedissonGeo.searchAsync(GeoSearchArgs args)
RFuture<Map<V,Double>>	RedissonGeo.searchWithDistanceAsync(GeoSearchArgs args)
RFuture<Map<V,GeoPosition>>	RedissonGeo.searchWithPositionAsync(GeoSearchArgs args)
RFuture<Void>	RedissonBucket.setAndKeepTTLAsync(V value)
RFuture<Void>	RedissonJsonBucket.setAndKeepTTLAsync(V value)
RFuture<Void>	RedissonAtomicDouble.setAsync(double newValue)
RFuture<Void>	RedissonAtomicLong.setAsync(long newValue)
RFuture<Boolean>	RedissonBitSet.setAsync(long bitIndex)
RFuture<Boolean>	RedissonBitSet.setAsync(long bitIndex, boolean value)
RFuture<Void>	RedissonBitSet.setAsync(long fromIndex, long toIndex)
RFuture<Void>	RedissonBitSet.setAsync(long fromIndex, long toIndex, boolean value)
RFuture<Void>	RedissonBitSet.setAsync(BitSet bs)
RFuture<Void>	RedissonBucket.setAsync(V value)
RFuture<Void>	RedissonBucket.setAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Void>	RedissonBuckets.setAsync(Map<String,?> buckets)
RFuture<Void>	RedissonJsonBucket.setAsync(String path, Object value)
RFuture<Void>	RedissonJsonBucket.setAsync(V value)
RFuture<Void>	RedissonJsonBucket.setAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<V>	RedissonList.setAsync(int index, V element)
RFuture<V>	RedissonListMultimapValues.setAsync(int index, V element)
RFuture<V>	RedissonSubList.setAsync(int index, V element)
RFuture<Byte>	RedissonBitSet.setByteAsync(long offset, byte value)
RFuture<Void>	RedissonRingBuffer.setCapacityAsync(int capacity)
RFuture<Boolean>	RedissonBucket.setIfAbsentAsync(V value)
RFuture<Boolean>	RedissonBucket.setIfAbsentAsync(V value, Duration duration)
RFuture<Boolean>	RedissonJsonBucket.setIfAbsentAsync(String path, Object value)
RFuture<Boolean>	RedissonJsonBucket.setIfAbsentAsync(V value)
RFuture<Boolean>	RedissonJsonBucket.setIfAbsentAsync(V value, Duration duration)
RFuture<Boolean>	RedissonBucket.setIfExistsAsync(V value)
RFuture<Boolean>	RedissonBucket.setIfExistsAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonJsonBucket.setIfExistsAsync(String path, Object value)
RFuture<Boolean>	RedissonJsonBucket.setIfExistsAsync(V value)
RFuture<Boolean>	RedissonJsonBucket.setIfExistsAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Integer>	RedissonBitSet.setIntegerAsync(long offset, int value)
RFuture<Long>	RedissonBitSet.setLongAsync(long offset, long value)
RFuture<Void>	RedissonMapCache.setMaxSizeAsync(int maxSize)
RFuture<Void>	RedissonMapCache.setMaxSizeAsync(int maxSize, EvictionMode mode)
RFuture<Void>	RedissonRateLimiter.setRateAsync(RateType type, long rate, long rateInterval, RateIntervalUnit unit)
RFuture<Short>	RedissonBitSet.setShortAsync(long offset, short value)
RFuture<Long>	RedissonBitSet.setSignedAsync(int size, long offset, long value)
RFuture<Long>	RedissonBitSet.setUnsignedAsync(int size, long offset, long value)
RFuture<Long>	RedissonBitSet.sizeAsync()
RFuture<Long>	RedissonBucket.sizeAsync()
RFuture<Integer>	RedissonDelayedQueue.sizeAsync()
RFuture<Long>	RedissonJsonBucket.sizeAsync()
RFuture<Integer>	RedissonList.sizeAsync()
RFuture<Integer>	RedissonListMultimap.sizeAsync()
RFuture<Integer>	RedissonListMultimapValues.sizeAsync()
RFuture<Integer>	RedissonLocalCachedMap.sizeAsync()
RFuture<Integer>	RedissonMap.sizeAsync()
RFuture<Long>	RedissonReliableTopic.sizeAsync()
RFuture<Integer>	RedissonScoredSortedSet.sizeAsync()
RFuture<Integer>	RedissonSet.sizeAsync()
RFuture<Integer>	RedissonSetCache.sizeAsync()
RFuture<Integer>	RedissonSetMultimap.sizeAsync()
RFuture<Integer>	RedissonSetMultimapValues.sizeAsync()
RFuture<Long>	RedissonStream.sizeAsync()
RFuture<Integer>	RedissonSubList.sizeAsync()
RFuture<Integer>	RedissonTimeSeries.sizeAsync()
RFuture<Integer>	RedissonTransferQueue.sizeAsync()
RFuture<Long>	RedissonBloomFilter.sizeInMemoryAsync()
RFuture<Long>	RedissonBoundedBlockingQueue.sizeInMemoryAsync()
RFuture<Long>	RedissonDelayedQueue.sizeInMemoryAsync()
RFuture<Long>	RedissonFairLock.sizeInMemoryAsync()
RFuture<Long>	RedissonIdGenerator.sizeInMemoryAsync()
RFuture<Long>	RedissonListMultimapCache.sizeInMemoryAsync()
RFuture<Long>	RedissonListMultimapValues.sizeInMemoryAsync()
RFuture<Long>	RedissonLocalCachedMap.sizeInMemoryAsync()
RFuture<Long>	RedissonMapCache.sizeInMemoryAsync()
RFuture<Long>	RedissonMultimap.sizeInMemoryAsync()
RFuture<Long>	RedissonMultimapCache.sizeInMemoryAsync()
RFuture<Long>	RedissonObject.sizeInMemoryAsync()
final RFuture<Long>	RedissonObject.sizeInMemoryAsync(List<Object> keys)
final RFuture<Long>	RedissonObject.sizeInMemoryAsync(CommandAsyncExecutor commandExecutor, List<Object> keys)
RFuture<Long>	RedissonPermitExpirableSemaphore.sizeInMemoryAsync()
RFuture<Long>	RedissonReliableTopic.sizeInMemoryAsync()
RFuture<Long>	RedissonSetMultimapCache.sizeInMemoryAsync()
RFuture<Long>	RedissonSetMultimapValues.sizeInMemoryAsync()
RFuture<Long>	RedissonTimeSeries.sizeInMemoryAsync()
RFuture<Integer>	RedissonList.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)
RFuture<Integer>	RedissonList.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonList.sortToAsync(String destName, String byPattern, SortOrder order)
RFuture<Integer>	RedissonList.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonList.sortToAsync(String destName, SortOrder order)
RFuture<Integer>	RedissonList.sortToAsync(String destName, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, String byPattern, SortOrder order)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, SortOrder order)
RFuture<Integer>	RedissonListMultimapValues.sortToAsync(String destName, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, String byPattern, SortOrder order)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, SortOrder order)
RFuture<Integer>	RedissonScoredSortedSet.sortToAsync(String destName, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, String byPattern, SortOrder order)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, SortOrder order)
RFuture<Integer>	RedissonSet.sortToAsync(String destName, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, String byPattern, SortOrder order)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, SortOrder order)
RFuture<Integer>	RedissonSetMultimapValues.sortToAsync(String destName, SortOrder order, int offset, int count)
RFuture<FunctionStats>	RedissonFuction.statsAsync()
RFuture<Long>	RedissonGeo.storeSearchToAsync(String destName, GeoSearchArgs args)
RFuture<Long>	RedissonGeo.storeSortedSearchToAsync(String destName, GeoSearchArgs args)
RFuture<Long>	RedissonJsonBucket.stringAppendAsync(String path, Object value)
RFuture<List<Long>>	RedissonJsonBucket.stringAppendMultiAsync(String path, Object value)
RFuture<Long>	RedissonJsonBucket.stringSizeAsync(String path)
RFuture<List<Long>>	RedissonJsonBucket.stringSizeMultiAsync(String path)
RFuture<T>	RedissonBaseAdder.sumAsync()
RFuture<T>	RedissonBaseAdder.sumAsync(long timeout, TimeUnit timeUnit)
RFuture<Void>	RedissonKeys.swapdbAsync(int db1, int db2)
RFuture<V>	RedissonBlockingDeque.takeAsync()
RFuture<V>	RedissonBlockingQueue.takeAsync()
RFuture<V>	RedissonBoundedBlockingQueue.takeAsync()
RFuture<V>	RedissonPriorityBlockingDeque.takeAsync()
RFuture<V>	RedissonPriorityBlockingQueue.takeAsync()
RFuture<V>	RedissonTransferQueue.takeAsync()
RFuture<V>	RedissonBlockingDeque.takeFirstAsync()
RFuture<V>	RedissonPriorityBlockingDeque.takeFirstAsync()
RFuture<V>	RedissonScoredSortedSet.takeFirstAsync()
RFuture<V>	RedissonBlockingDeque.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonBlockingQueue.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonBoundedBlockingQueue.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonPriorityBlockingDeque.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonPriorityBlockingQueue.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonTransferQueue.takeLastAndOfferFirstToAsync(String queueName)
RFuture<V>	RedissonBlockingDeque.takeLastAsync()
RFuture<V>	RedissonPriorityBlockingDeque.takeLastAsync()
RFuture<V>	RedissonScoredSortedSet.takeLastAsync()
RFuture<byte[]>	RedissonBitSet.toByteArrayAsync()
RFuture<Boolean>	RedissonJsonBucket.toggleAsync(String path)
RFuture<List<Boolean>>	RedissonJsonBucket.toggleMultiAsync(String path)
RFuture<Long>	RedissonKeys.touchAsync(String... names)
RFuture<Boolean>	RedissonObject.touchAsync()
RFuture<Void>	RedissonTransferQueue.transferAsync(V v)
RFuture<Void>	RedissonList.trimAsync(int fromIndex, int toIndex)
RFuture<Void>	RedissonListMultimapValues.trimAsync(int fromIndex, int toIndex)
RFuture<Long>	RedissonStream.trimAsync(int count)
RFuture<Long>	RedissonStream.trimAsync(StreamTrimArgs args)
RFuture<Long>	RedissonStream.trimAsync(TrimStrategy strategy, int threshold)
RFuture<Void>	RedissonSubList.trimAsync(int fromIndex, int toIndex)
RFuture<Long>	RedissonStream.trimNonStrictAsync(int count)
RFuture<Long>	RedissonStream.trimNonStrictAsync(StreamTrimArgs args)
RFuture<Long>	RedissonStream.trimNonStrictAsync(TrimStrategy strategy, int threshold)
RFuture<Long>	RedissonStream.trimNonStrictAsync(TrimStrategy strategy, int threshold, int limit)
RFuture<String>	RedissonPermitExpirableSemaphore.tryAcquireAsync()
RFuture<String>	RedissonPermitExpirableSemaphore.tryAcquireAsync(long waitTime, long ttl, TimeUnit unit)
RFuture<String>	RedissonPermitExpirableSemaphore.tryAcquireAsync(long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonQueueSemaphore.tryAcquireAsync(int permits)
RFuture<Boolean>	RedissonRateLimiter.tryAcquireAsync()
RFuture<Boolean>	RedissonRateLimiter.tryAcquireAsync(long permits)
RFuture<Boolean>	RedissonRateLimiter.tryAcquireAsync(long permits, long timeout, TimeUnit unit)
RFuture<Boolean>	RedissonRateLimiter.tryAcquireAsync(long timeout, TimeUnit unit)
RFuture<Boolean>	RedissonSemaphore.tryAcquireAsync()
RFuture<Boolean>	RedissonSemaphore.tryAcquireAsync(int permits)
RFuture<Boolean>	RedissonSemaphore.tryAcquireAsync(int permits, long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonSemaphore.tryAcquireAsync(long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonGeo.tryAddAsync(double longitude, double latitude, V member)
RFuture<Long>	RedissonGeo.tryAddAsync(GeoEntry... entries)
RFuture<Boolean>	RedissonScoredSortedSet.tryAddAsync(double score, V object)
RFuture<Boolean>	RedissonSet.tryAddAsync(V... values)
RFuture<Boolean>	RedissonSetCache.tryAddAsync(long ttl, TimeUnit unit, V... values)
RFuture<Boolean>	RedissonSetCache.tryAddAsync(V... values)
RFuture<Boolean>	RedissonSetMultimapValues.tryAddAsync(V... values)
<T> RFuture<Boolean>	RedissonRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object)
<T> RFuture<Boolean>	RedissonRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object, long timeout, TimeUnit timeUnit)
<T> RFuture<Boolean>	RedissonRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object, ExecutorService executor, long timeout, TimeUnit timeUnit)
RFuture<Boolean>	RedissonIdGenerator.tryInitAsync(long value, long allocationSize)
RFuture<Boolean>	RedissonLock.tryLockAsync()
RFuture<Boolean>	RedissonLock.tryLockAsync(long threadId)
RFuture<Boolean>	RedissonLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)
RFuture<Boolean>	RedissonLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long currentThreadId)
RFuture<Boolean>	RedissonLock.tryLockAsync(long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonMultiLock.tryLockAsync()
RFuture<Boolean>	RedissonMultiLock.tryLockAsync(long threadId)
RFuture<Boolean>	RedissonMultiLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)
RFuture<Boolean>	RedissonMultiLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId)
RFuture<Boolean>	RedissonMultiLock.tryLockAsync(long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonSpinLock.tryLockAsync()
RFuture<Boolean>	RedissonSpinLock.tryLockAsync(long threadId)
RFuture<Boolean>	RedissonSpinLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)
RFuture<Boolean>	RedissonSpinLock.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long currentThreadId)
RFuture<Boolean>	RedissonSpinLock.tryLockAsync(long waitTime, TimeUnit unit)
RFuture<Boolean>	RedissonPermitExpirableSemaphore.tryReleaseAsync(String permitId)
RFuture<Boolean>	RedissonBucket.trySetAsync(V value)
RFuture<Boolean>	RedissonBucket.trySetAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonBuckets.trySetAsync(Map<String,?> buckets)
RFuture<Boolean>	RedissonJsonBucket.trySetAsync(String path, Object value)
RFuture<Boolean>	RedissonJsonBucket.trySetAsync(V value)
RFuture<Boolean>	RedissonJsonBucket.trySetAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonBoundedBlockingQueue.trySetCapacityAsync(int capacity)
RFuture<Boolean>	RedissonRingBuffer.trySetCapacityAsync(int capacity)
RFuture<Boolean>	RedissonCountDownLatch.trySetCountAsync(long count)
RFuture<Boolean>	RedissonMapCache.trySetMaxSizeAsync(int maxSize)
RFuture<Boolean>	RedissonMapCache.trySetMaxSizeAsync(int maxSize, EvictionMode mode)
RFuture<Boolean>	RedissonPermitExpirableSemaphore.trySetPermitsAsync(int permits)
RFuture<Boolean>	RedissonSemaphore.trySetPermitsAsync(int permits)
RFuture<Boolean>	RedissonRateLimiter.trySetRateAsync(RateType type, long rate, long rateInterval, RateIntervalUnit unit)
RFuture<Boolean>	RedissonTransferQueue.tryTransferAsync(V v)
RFuture<Boolean>	RedissonTransferQueue.tryTransferAsync(V v, long timeout, TimeUnit unit)
RFuture<Integer>	RedissonScoredSortedSet.unionAsync(String... names)
RFuture<Integer>	RedissonScoredSortedSet.unionAsync(Map<String,Double> nameWithWeight)
RFuture<Integer>	RedissonScoredSortedSet.unionAsync(RScoredSortedSet.Aggregate aggregate, String... names)
RFuture<Integer>	RedissonScoredSortedSet.unionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)
RFuture<Integer>	RedissonSet.unionAsync(String... names)
RFuture<Integer>	RedissonSetMultimapValues.unionAsync(String... names)
RFuture<Long>	RedissonKeys.unlinkAsync(String... keys)
RFuture<Boolean>	RedissonObject.unlinkAsync()
RFuture<Void>	RedissonBaseLock.unlockAsync()
RFuture<Void>	RedissonBaseLock.unlockAsync(long threadId)
RFuture<Void>	RedissonMultiLock.unlockAsync()
RFuture<Void>	RedissonMultiLock.unlockAsync(long threadId)
protected abstract RFuture<Boolean>	RedissonBaseLock.unlockInnerAsync(long threadId)
protected RFuture<Boolean>	RedissonFairLock.unlockInnerAsync(long threadId)
protected RFuture<Boolean>	RedissonLock.unlockInnerAsync(long threadId)
protected RFuture<Void>	RedissonMultiLock.unlockInnerAsync(Collection<RLock> locks, long threadId)
protected RFuture<Boolean>	RedissonReadLock.unlockInnerAsync(long threadId)
protected RFuture<Boolean>	RedissonSpinLock.unlockInnerAsync(long threadId)
protected RFuture<Boolean>	RedissonWriteLock.unlockInnerAsync(long threadId)
RFuture<Boolean>	RedissonMapCache.updateEntryExpirationAsync(K key, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<Void>	RedissonStream.updateGroupMessageIdAsync(String groupName, StreamMessageId id)
RFuture<Boolean>	RedissonPermitExpirableSemaphore.updateLeaseTimeAsync(String permitId, long leaseTime, TimeUnit unit)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeAsync(int startIndex, int endIndex)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)
RFuture<Collection<V>>	RedissonScoredSortedSet.valueRangeReversedAsync(int startIndex, int endIndex)
RFuture<Integer>	RedissonMap.valueSizeAsync(K key)
protected final <T, R> RFuture<R>	RedissonPriorityQueue.wrapLockedAsync(Supplier<RFuture<R>> callable)
protected <T> RFuture<V>	RedissonPriorityQueue.wrapLockedAsync(RedisCommand<T> command, Object... params)
RFuture<Void>	RedissonBitSet.xorAsync(String... bitSetNames)

Methods in org.redisson with parameters of type RFuture

Modifier and Type	Method	Description
protected final <V> V	RedissonObject.get(RFuture<V> future)
protected final <M> RFuture<M>	RedissonMap.mapWriterFuture(RFuture<M> future, MapWriterTask task)
protected final <M> RFuture<M>	RedissonMap.mapWriterFuture(RFuture<M> future, MapWriterTask task, Function<M,Boolean> condition)
void	RedissonRemoteService.Entry.setFuture(RFuture<String> future)

Method parameters in org.redisson with type arguments of type RFuture

Modifier and Type	Method	Description
<V> int	ElementsSubscribeService.subscribeOnElements(Supplier<RFuture<V>> func, Consumer<V> consumer)
protected final <T, R> RFuture<R>	RedissonPriorityQueue.wrapLockedAsync(Supplier<RFuture<R>> callable)

Uses of RFuture in org.redisson.api

Subinterfaces of RFuture in org.redisson.api

Modifier and Type	Interface	Description
interface	RExecutorBatchFuture	Future object for submitted tasks in a batch
interface	RExecutorFuture<V>	Future object for submitted task
interface	RScheduledFuture<V>

Methods in org.redisson.api that return RFuture

Modifier and Type	Method	Description
RFuture<Long>	RStreamAsync.ackAsync(String groupName, StreamMessageId... ids)	Marks pending messages by group name and stream ids as correctly processed.
RFuture<String>	RPermitExpirableSemaphoreAsync.acquireAsync()	Acquires a permit and returns its id.
RFuture<String>	RPermitExpirableSemaphoreAsync.acquireAsync(long leaseTime, TimeUnit unit)	Acquires a permit with defined leaseTime and return its id.
RFuture<Void>	RRateLimiterAsync.acquireAsync()	Acquires a permit from this RateLimiter, blocking until one is available.
RFuture<Void>	RRateLimiterAsync.acquireAsync(long permits)	Acquires a specified permits from this RateLimiter, blocking until one is available.
RFuture<Void>	RSemaphoreAsync.acquireAsync()	Acquires a permit.
RFuture<Void>	RSemaphoreAsync.acquireAsync(int permits)	Acquires defined amount of permits.
RFuture<Integer>	RListAsync.addAfterAsync(V elementToFind, V element)	Inserts element after elementToFind
RFuture<Boolean>	RCollectionAsync.addAllAsync(Collection<? extends V> c)	Adds all elements contained in the specified collection
RFuture<Boolean>	RHyperLogLogAsync.addAllAsync(Collection<V> objects)	Adds all elements contained in objects collection into this structure
RFuture<Boolean>	RListAsync.addAllAsync(int index, Collection<? extends V> elements)	Inserts elements at index.
RFuture<Integer>	RScoredSortedSetAsync.addAllAsync(Map<V,Double> objects)	Adds all elements contained in the specified map to this sorted set.
RFuture<StreamMessageId>	RStreamAsync.addAllAsync(Map<K,V> entries)	Deprecated.
RFuture<StreamMessageId>	RStreamAsync.addAllAsync(Map<K,V> entries, int trimLen, boolean trimStrict)	Deprecated.
RFuture<Void>	RStreamAsync.addAllAsync(StreamMessageId id, Map<K,V> entries)	Deprecated.
RFuture<Void>	RStreamAsync.addAllAsync(StreamMessageId id, Map<K,V> entries, int trimLen, boolean trimStrict)	Deprecated.
RFuture<Void>	RTimeSeriesAsync.addAllAsync(Collection<TimeSeriesEntry<V,L>> entries)	Adds all entries collection to this time-series collection.
RFuture<Void>	RTimeSeriesAsync.addAllAsync(Collection<TimeSeriesEntry<V,L>> entries, Duration timeToLive)	Adds all time series entries collection to this time-series collection.
RFuture<Void>	RTimeSeriesAsync.addAllAsync(Map<Long,V> objects)	Adds all elements contained in the specified map to this time-series collection.
RFuture<Void>	RTimeSeriesAsync.addAllAsync(Map<Long,V> objects, long timeToLive, TimeUnit timeUnit)	Adds all elements contained in the specified map to this time-series collection.
RFuture<Integer>	RSetAsync.addAllCountedAsync(Collection<? extends V> c)	Adds all elements contained in the specified collection.
RFuture<Integer>	RScoredSortedSetAsync.addAllIfAbsentAsync(Map<V,Double> objects)	Adds elements to this set only if they haven't been added before.
RFuture<Integer>	RScoredSortedSetAsync.addAllIfExistAsync(Map<V,Double> objects)	Adds elements to this set only if they already exist.
RFuture<Integer>	RScoredSortedSetAsync.addAllIfGreaterAsync(Map<V,Double> objects)	Adds elements to this set only if new scores greater than current score of existed elements.
RFuture<Integer>	RScoredSortedSetAsync.addAllIfLessAsync(Map<V,Double> objects)	Adds elements to this set only if new scores less than current score of existed elements.
RFuture<Double>	RAtomicDoubleAsync.addAndGetAsync(double delta)	Atomically adds the given value to the current value.
RFuture<Long>	RAtomicLongAsync.addAndGetAsync(long delta)	Atomically adds the given value to the current value.
RFuture<V>	RMapAsync.addAndGetAsync(K key, Number delta)	Adds the given delta to the current value by mapped key.
RFuture<Integer>	RScoredSortedSetAsync.addAndGetRankAsync(double score, V object)	Adds element to this set, overrides previous score if it has been already added.
RFuture<Integer>	RScoredSortedSetAsync.addAndGetRevRankAsync(double score, V object)	Adds element to this set, overrides previous score if it has been already added.
RFuture<List<Integer>>	RScoredSortedSetAsync.addAndGetRevRankAsync(Map<? extends V,Double> map)	Adds elements to this set, overrides previous score if it has been already added.
RFuture<Boolean>	RCollectionAsync.addAsync(V e)	Adds element into this collection.
RFuture<Long>	RGeoAsync.addAsync(double longitude, double latitude, V member)	Adds geospatial member.
RFuture<Long>	RGeoAsync.addAsync(GeoEntry... entries)	Adds geospatial members.
RFuture<Boolean>	RHyperLogLogAsync.addAsync(V obj)	Adds element into this structure.
RFuture<Boolean>	RListAsync.addAsync(int index, V element)	Inserts element at index.
RFuture<Boolean>	RScoredSortedSetAsync.addAsync(double score, V object)	Adds element to this set, overrides previous score if it has been already added.
RFuture<Boolean>	RSetCacheAsync.addAsync(V value, long ttl, TimeUnit unit)	Stores value with specified time to live.
RFuture<Boolean>	RSortedSet.addAsync(V value)
RFuture<StreamMessageId>	RStreamAsync.addAsync(K key, V value)	Deprecated.
RFuture<StreamMessageId>	RStreamAsync.addAsync(K key, V value, int trimLen, boolean trimStrict)	Deprecated.
RFuture<StreamMessageId>	RStreamAsync.addAsync(StreamAddArgs<K,V> args)	Appends a new entry/entries and returns generated Stream Message ID
RFuture<Void>	RStreamAsync.addAsync(StreamMessageId id, K key, V value)	Deprecated.
RFuture<Void>	RStreamAsync.addAsync(StreamMessageId id, K key, V value, int trimLen, boolean trimStrict)	Deprecated.
RFuture<Void>	RStreamAsync.addAsync(StreamMessageId id, StreamAddArgs<K,V> args)	Appends a new entry/entries by specified Stream Message ID
RFuture<Void>	RTimeSeriesAsync.addAsync(long timestamp, V object)	Adds element to this time-series collection by specified timestamp.
RFuture<Void>	RTimeSeriesAsync.addAsync(long timestamp, V object, long timeToLive, TimeUnit timeUnit)	Adds element to this time-series collection by specified timestamp.
RFuture<Void>	RTimeSeriesAsync.addAsync(long timestamp, V object, L label)	Adds element with label to this time-series collection by specified timestamp.
RFuture<Void>	RTimeSeriesAsync.addAsync(long timestamp, V object, L label, Duration timeToLive)	Adds element with label to this time-series collection by specified timestamp.
RFuture<Integer>	RListAsync.addBeforeAsync(V elementToFind, V element)	Inserts element before elementToFind
RFuture<Void>	RDequeAsync.addFirstAsync(V e)	Adds element at the head of this deque.
RFuture<Integer>	RDequeAsync.addFirstAsync(V... elements)	Adds elements at the head of deque.
RFuture<Integer>	RDequeAsync.addFirstIfExistsAsync(V... elements)	Adds element at the head of existing deque.
RFuture<Boolean>	RScoredSortedSetAsync.addIfAbsentAsync(double score, V object)	Adds element to this set only if has not been added before.
RFuture<Boolean>	RGeoAsync.addIfExistsAsync(double longitude, double latitude, V member)	Adds geospatial member only if it's already exists.
RFuture<Long>	RGeoAsync.addIfExistsAsync(GeoEntry... entries)	Adds geospatial members only if it's already exists.
RFuture<Boolean>	RScoredSortedSetAsync.addIfExistsAsync(double score, V object)	Adds element to this set only if it's already exists.
RFuture<Boolean>	RScoredSortedSetAsync.addIfGreaterAsync(double score, V object)	Adds element to this set only if new score greater than current score of existed element.
RFuture<Boolean>	RScoredSortedSetAsync.addIfLessAsync(double score, V object)	Adds element to this set only if new score less than current score of existed element.
RFuture<Void>	RDequeAsync.addLastAsync(V e)	Adds element at the tail of this deque.
RFuture<Integer>	RDequeAsync.addLastAsync(V... elements)	Adds elements at the tail of deque.
RFuture<Integer>	RDequeAsync.addLastIfExistsAsync(V... elements)	Adds element at the tail of existing deque.
RFuture<Integer>	RBucketAsync.addListenerAsync(ObjectListener listener)	Adds object event listener
RFuture<Integer>	RListAsync.addListenerAsync(ObjectListener listener)	Adds object event listener
RFuture<Integer>	RObjectAsync.addListenerAsync(ObjectListener listener)	Adds object event listener
<T> RFuture<Integer>	RPatternTopic.addListenerAsync(Class<T> type, PatternMessageListener<T> listener)
RFuture<Integer>	RPatternTopic.addListenerAsync(PatternStatusListener listener)
RFuture<Integer>	RQueueAsync.addListenerAsync(ObjectListener listener)	Adds object event listener
<M> RFuture<String>	RReliableTopicAsync.addListenerAsync(Class<M> type, MessageListener<M> listener)	Subscribes to this topic.
<M> RFuture<Integer>	RTopicAsync.addListenerAsync(Class<M> type, MessageListener<M> listener)	Subscribes to this topic.
RFuture<Integer>	RTopicAsync.addListenerAsync(StatusListener listener)	Subscribes to status changes of this topic
RFuture<Void>	RPermitExpirableSemaphoreAsync.addPermitsAsync(int permits)	Increases or decreases the number of available permits by defined value.
RFuture<Void>	RSemaphoreAsync.addPermitsAsync(int permits)	Increases or decreases the number of available permits by defined value.
RFuture<Integer>	RScoredSortedSetAsync.addScoreAndGetRankAsync(V object, Number value)	Adds score to element and returns its rank
RFuture<Integer>	RScoredSortedSetAsync.addScoreAndGetRevRankAsync(V object, Number value)	Adds score to element and returns its reverse rank
RFuture<Double>	RScoredSortedSetAsync.addScoreAsync(V element, Number value)	Increases score of specified element by value.
RFuture<Void>	RBitSetAsync.andAsync(String... bitSetNames)	Executes AND operation over this object and specified bitsets.
RFuture<Long>	RJsonBucketAsync.arrayAppendAsync(String path, Object... values)	Appends values to array specified by JSONPath.
RFuture<List<Long>>	RJsonBucketAsync.arrayAppendMultiAsync(String path, Object... values)	Appends values to arrays specified by JSONPath.
RFuture<Long>	RJsonBucketAsync.arrayIndexAsync(String path, Object value)	Returns index of object in array specified by JSONPath
RFuture<Long>	RJsonBucketAsync.arrayIndexAsync(String path, Object value, long start, long end)	Returns index of object in array specified by JSONPath in range between start (inclusive) and end (exclusive) indexes
RFuture<List<Long>>	RJsonBucketAsync.arrayIndexMultiAsync(String path, Object value)	Returns index of object in arrays specified by JSONPath
RFuture<List<Long>>	RJsonBucketAsync.arrayIndexMultiAsync(String path, Object value, long start, long end)	Returns index of object in arrays specified by JSONPath in range between start (inclusive) and end (exclusive) indexes
RFuture<Long>	RJsonBucketAsync.arrayInsertAsync(String path, long index, Object... values)	Inserts values into array specified by JSONPath.
RFuture<List<Long>>	RJsonBucketAsync.arrayInsertMultiAsync(String path, long index, Object... values)	Inserts values into arrays specified by JSONPath.
<T> RFuture<T>	RJsonBucketAsync.arrayPollFirstAsync(JsonCodec<T> codec, String path)	Polls first element of array specified by JSONPath.
<T> RFuture<List<T>>	RJsonBucketAsync.arrayPollFirstMultiAsync(JsonCodec<T> codec, String path)	Polls first element of arrays specified by JSONPath.
<T> RFuture<T>	RJsonBucketAsync.arrayPollLastAsync(JsonCodec<T> codec, String path)	Polls last element of array specified by JSONPath.
<T> RFuture<List<T>>	RJsonBucketAsync.arrayPollLastMultiAsync(JsonCodec<T> codec, String path)	Polls last element of arrays specified by JSONPath.
<T> RFuture<T>	RJsonBucketAsync.arrayPopAsync(JsonCodec<T> codec, String path, long index)	Pops element located at index of array specified by JSONPath.
<T> RFuture<List<T>>	RJsonBucketAsync.arrayPopMultiAsync(JsonCodec<T> codec, String path, long index)	Pops elements located at index of arrays specified by JSONPath.
RFuture<Long>	RJsonBucketAsync.arraySizeAsync(String path)	Returns size of array specified by JSONPath.
RFuture<List<Long>>	RJsonBucketAsync.arraySizeMultiAsync(String path)	Returns size of arrays specified by JSONPath.
RFuture<Long>	RJsonBucketAsync.arrayTrimAsync(String path, long start, long end)	Trims array specified by JSONPath in range between start (inclusive) and end (inclusive) indexes.
RFuture<List<Long>>	RJsonBucketAsync.arrayTrimMultiAsync(String path, long start, long end)	Trims arrays specified by JSONPath in range between start (inclusive) and end (inclusive) indexes.
RFuture<AutoClaimResult<K,V>>	RStreamAsync.autoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count)	Transfers ownership of pending messages by id to a new consumer by name if idle time of messages and startId are greater than defined value.
RFuture<Integer>	RPermitExpirableSemaphoreAsync.availablePermitsAsync()	Returns amount of available permits.
RFuture<Long>	RRateLimiterAsync.availablePermitsAsync()	Returns amount of available permits.
RFuture<Integer>	RSemaphoreAsync.availablePermitsAsync()	Returns amount of available permits.
RFuture<V>	RFuture.await()	Deprecated.
RFuture<Void>	RCountDownLatchAsync.awaitAsync()	Waits until counter reach zero.
RFuture<Boolean>	RCountDownLatchAsync.awaitAsync(long waitTime, TimeUnit unit)	Waits until counter reach zero or up to defined timeout.
RFuture<V>	RFuture.awaitUninterruptibly()	Deprecated.
<R> RFuture<R>	RFunctionAsync.callAsync(String key, FunctionMode mode, String name, FunctionResult returnType, List<Object> keys, Object... values)	Executes function
<R> RFuture<R>	RFunctionAsync.callAsync(FunctionMode mode, String name, FunctionResult returnType)	Executes function
<R> RFuture<R>	RFunctionAsync.callAsync(FunctionMode mode, String name, FunctionResult returnType, List<Object> keys, Object... values)	Executes function
RFuture<Boolean>	RExecutorServiceAsync.cancelTaskAsync(String taskId)	Cancel task by id
RFuture<Integer>	RRingBufferAsync.capacityAsync()	Returns capacity of this queue
RFuture<Long>	RBitSetAsync.cardinalityAsync()	Returns the number of bits set to one.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.claimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId... ids)	Transfers ownership of pending messages by id to a new consumer by name if idle time of messages is greater than defined value.
RFuture<Void>	CacheAsync.clearAsync()	This method empties the cache's contents, without notifying listeners or CacheWriters.
RFuture<Void>	RBitSetAsync.clearAsync()	Set all bits to zero
RFuture<Boolean>	RBitSetAsync.clearAsync(long bitIndex)	Set bit to zero at specified bitIndex
RFuture<Void>	RBitSetAsync.clearAsync(long fromIndex, long toIndex)	Set all bits to zero from fromIndex (inclusive) to toIndex (exclusive)
RFuture<Long>	RJsonBucketAsync.clearAsync()	Clears json container.
RFuture<Long>	RJsonBucketAsync.clearAsync(String path)	Clears json container specified by JSONPath.
RFuture<Boolean>	RExpirableAsync.clearExpireAsync()	Clear an expire timeout or expire date for object in async mode.
RFuture<Boolean>	RKeysAsync.clearExpireAsync(String name)	Clear an expire timeout or expire date for object.
RFuture<Void>	RLocalCachedMap.clearLocalCacheAsync()	Clears local cache across all instances
RFuture<Map<String,String>>	NodeAsync.clusterInfoAsync()	Deprecated.
RFuture<Void>	RTransaction.commitAsync()	Commits all changes made on this transaction in async mode.
RFuture<Boolean>	RAtomicDoubleAsync.compareAndSetAsync(double expect, double update)	Atomically sets the value to the given updated value only if the current value == the expected value.
RFuture<Boolean>	RAtomicLongAsync.compareAndSetAsync(long expect, long update)	Atomically sets the value to the given updated value only if the current value == the expected value.
RFuture<Boolean>	RBucketAsync.compareAndSetAsync(V expect, V update)	Atomically sets the value to the given updated value only if serialized state of the current value equals to serialized state of the expected value.
RFuture<Boolean>	RJsonBucketAsync.compareAndSetAsync(String path, Object expect, Object update)	Atomically sets the value to the given updated value by given JSONPath, only if serialized state of the current value equals to serialized state of the expected value.
RFuture<V>	RMapAsync.computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	Computes a new mapping for the specified key and its current mapped value.
RFuture<V>	RMapAsync.computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction)	Computes a mapping for the specified key if it's not mapped before.
RFuture<V>	RMapAsync.computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)	Computes a mapping for the specified key only if it's already mapped.
RFuture<Boolean>	RCollectionAsync.containsAllAsync(Collection<?> c)	Returns true if this collection contains all of the elements in the specified collection.
RFuture<Boolean>	RScoredSortedSetAsync.containsAllAsync(Collection<?> c)	Returns true if this sorted set contains all of the elements in encoded state in the specified collection.
RFuture<Boolean>	RCollectionAsync.containsAsync(Object o)	Returns true if this collection contains encoded state of the specified element.
RFuture<Boolean>	RScoredSortedSetAsync.containsAsync(Object o)	Returns true if this sorted set contains encoded state of the specified element.
RFuture<Boolean>	RMultimapAsync.containsEntryAsync(Object key, Object value)	Returns true if this multimap contains at least one key-value pair with the key key and the value value.
RFuture<Boolean>	CacheAsync.containsKeyAsync(K key)	This method returns a Boolean true/false value, depending on whether the CacheAsync has a mapping for a key k such that key.equals(k).
RFuture<Boolean>	RMapAsync.containsKeyAsync(Object key)	Returns true if this map contains map entry mapped by specified key, otherwise false
RFuture<Boolean>	RMultimapAsync.containsKeyAsync(Object key)	Returns true if this multimap contains at least one key-value pair with the key key.
RFuture<Boolean>	RMapAsync.containsValueAsync(Object value)	Returns true if this map contains any map entry with specified value, otherwise false
RFuture<Boolean>	RMultimapAsync.containsValueAsync(Object value)	Returns true if this multimap contains at least one key-value pair with the value value.
RFuture<Void>	RKeysAsync.copyAsync(String name, String host, int port, int database, long timeout)	Copy object from source Redis instance to destination Redis instance in async mode
RFuture<Void>	RObjectAsync.copyAsync(String host, int port, int database, long timeout)	Copy object from source Redis instance to destination Redis instance in async mode
RFuture<Long>	RHyperLogLogAsync.countAsync()	Returns approximated number of unique elements added into this structure.
RFuture<Long>	RKeysAsync.countAsync()	Returns the number of keys in the currently-selected database in async mode
RFuture<Integer>	RLexSortedSetAsync.countAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)	Returns the number of elements between fromElement and toElement.
RFuture<Integer>	RScoredSortedSetAsync.countAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Returns the number of elements with a score between startScore and endScore.
RFuture<Void>	RCountDownLatchAsync.countDownAsync()	Decrements the counter of the latch.
RFuture<Long>	RKeysAsync.countExistsAsync(String... names)	Checks if provided keys exist
RFuture<Integer>	RLexSortedSetAsync.countHeadAsync(String toElement, boolean toInclusive)	Returns the number of head values ending with toElement.
RFuture<Integer>	RScoredSortedSetAsync.countIntersectionAsync(int limit, String... names)	Counts elements of set as a result of sets intersection with current set.
RFuture<Integer>	RScoredSortedSetAsync.countIntersectionAsync(String... names)	Counts elements of set as a result of sets intersection with current set.
RFuture<Integer>	RSetAsync.countIntersectionAsync(int limit, String... names)	Counts elements of set as a result of sets intersection with current set.
RFuture<Integer>	RSetAsync.countIntersectionAsync(String... names)	Counts elements of set as a result of sets intersection with current set.
RFuture<Long>	RJsonBucketAsync.countKeysAsync()	Returns keys amount in JSON container
RFuture<Long>	RJsonBucketAsync.countKeysAsync(String path)	Returns keys amount in JSON container specified by JSONPath
RFuture<List<Long>>	RJsonBucketAsync.countKeysMultiAsync(String path)	Returns list of keys amount in JSON containers specified by JSONPath
RFuture<Integer>	RReliableTopicAsync.countSubscribersAsync()	Returns amount of subscribers to this topic across all Redisson instances.
RFuture<Long>	RTopicAsync.countSubscribersAsync()	Returns amount of subscribers to this topic across all Redisson instances.
RFuture<Integer>	RLexSortedSetAsync.countTailAsync(String fromElement, boolean fromInclusive)	Returns the number of tail values starting with fromElement.
RFuture<Long>	RHyperLogLogAsync.countWithAsync(String... otherLogNames)	Returns approximated number of unique elements added into this instances and other instances defined through otherLogNames.
RFuture<Void>	RStreamAsync.createConsumerAsync(String groupName, String consumerName)	Creates consumer of the group by name.
RFuture<Void>	RStreamAsync.createGroupAsync(String groupName)	Creates consumer group by name.
RFuture<Void>	RStreamAsync.createGroupAsync(String groupName, StreamMessageId id)	Creates consumer group by name and stream id.
RFuture<Double>	RAtomicDoubleAsync.decrementAndGetAsync()	Atomically decrements the current value by one.
RFuture<Long>	RAtomicLongAsync.decrementAndGetAsync()	Atomically decrements the current value by one.
RFuture<Boolean>	RExecutorServiceAsync.deleteAsync()	Deletes executor request queue and state objects
RFuture<Void>	RFunctionAsync.deleteAsync(String libraryName)	Deletes library.
RFuture<Long>	RJsonBucketAsync.deleteAsync(String path)	Deletes JSON elements specified by JSONPath
RFuture<Long>	RKeysAsync.deleteAsync(String... keys)	Delete multiple objects by name
RFuture<Long>	RKeysAsync.deleteAsync(RObject... objects)	Delete multiple objects
RFuture<Boolean>	RObjectAsync.deleteAsync()	Delete object in async mode
RFuture<Long>	RKeysAsync.deleteByPatternAsync(String pattern)	Delete multiple objects by a key pattern.
RFuture<Integer>	RScoredSortedSetAsync.diffAsync(String... names)	Diff provided ScoredSortedSets and store result to current ScoredSortedSet
RFuture<Integer>	RSetAsync.diffAsync(String... names)	Diff sets specified by name and write to current set.
RFuture<Void>	RBatch.discardAsync()	Discard batched commands and release allocated buffers used for parameters encoding.
RFuture<Double>	RGeoAsync.distAsync(V firstMember, V secondMember, GeoUnit geoUnit)	Returns distance between members in GeoUnit units.
RFuture<Integer>	RSemaphoreAsync.drainPermitsAsync()	Acquires and returns all permits that are immediately available.
RFuture<Integer>	RBlockingQueueAsync.drainToAsync(Collection<? super V> c)	Removes all available elements from this queue and adds them to the given collection in async mode.
RFuture<Integer>	RBlockingQueueAsync.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.
RFuture<byte[]>	RFunctionAsync.dumpAsync()	Returns serialized state of all libraries.
RFuture<byte[]>	RObjectAsync.dumpAsync()	Returns dump of object
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Returns all entries (value and its score) between startScore and endScore.
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Returns all entries (value and its score) between startScore and endScore.
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeAsync(int startIndex, int endIndex)	Returns entries (value and its score) by rank range.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.entryRangeAsync(long startTimestamp, long endTimestamp)	Returns ordered entries of this time-series collection within timestamp range.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.entryRangeAsync(long startTimestamp, long endTimestamp, int limit)	Returns ordered entries of this time-series collection within timestamp range.
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Returns all entries (value and its score) between startScore and endScore in reversed order.
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Returns all entries (value and its score) between startScore and endScore in reversed order.
RFuture<Collection<ScoredEntry<V>>>	RScoredSortedSetAsync.entryRangeReversedAsync(int startIndex, int endIndex)	Returns entries (value and its score) by rank range in reverse order.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.entryRangeReversedAsync(long startTimestamp, long endTimestamp)	Returns entries of this time-series collection in reverse order within timestamp range.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.entryRangeReversedAsync(long startTimestamp, long endTimestamp, int limit)	Returns entries of this time-series collection in reverse order within timestamp range.
<R> RFuture<R>	RScriptAsync.evalAsync(String key, RScript.Mode mode, String luaScript, RScript.ReturnType returnType, List<Object> keys, Object... values)	Executes Lua script
<R> RFuture<R>	RScriptAsync.evalAsync(RScript.Mode mode, String luaScript, RScript.ReturnType returnType)	Executes Lua script
<R> RFuture<R>	RScriptAsync.evalAsync(RScript.Mode mode, String luaScript, RScript.ReturnType returnType, List<Object> keys, Object... values)	Executes Lua script
<R> RFuture<R>	RScriptAsync.evalShaAsync(String key, RScript.Mode mode, String shaDigest, RScript.ReturnType returnType, List<Object> keys, Object... values)	Executes Lua script stored in Redis scripts cache by SHA-1 digest
<R> RFuture<R>	RScriptAsync.evalShaAsync(RScript.Mode mode, String shaDigest, RScript.ReturnType returnType)	Executes Lua script stored in Redis scripts cache by SHA-1 digest
<R> RFuture<R>	RScriptAsync.evalShaAsync(RScript.Mode mode, String shaDigest, RScript.ReturnType returnType, List<Object> keys, Object... values)	Executes Lua script stored in Redis scripts cache by SHA-1 digest
RFuture<BatchResult<?>>	RBatch.executeAsync()	Executes all operations accumulated during async methods invocations asynchronously.
RFuture<Boolean>	RExpirableAsync.expireAsync(long timeToLive, TimeUnit timeUnit)	Deprecated.
RFuture<Boolean>	RExpirableAsync.expireAsync(Duration duration)	Set a timeout for object.
RFuture<Boolean>	RExpirableAsync.expireAsync(Instant time)	Set an expire date for object.
RFuture<Boolean>	RKeysAsync.expireAsync(String name, long timeToLive, TimeUnit timeUnit)	Set a timeout for object.
RFuture<Boolean>	RExpirableAsync.expireAtAsync(long timestamp)	Deprecated.
RFuture<Boolean>	RExpirableAsync.expireAtAsync(Date timestamp)	Deprecated.
RFuture<Boolean>	RKeysAsync.expireAtAsync(String name, long timestamp)	Set an expire date for object.
RFuture<Boolean>	RExpirableAsync.expireIfGreaterAsync(Duration duration)	Sets a timeout for this object only if it's greater than timeout set before.
RFuture<Boolean>	RExpirableAsync.expireIfGreaterAsync(Instant time)	Sets an expiration date for this object only if it's greater than expiration date set before.
RFuture<Boolean>	RExpirableAsync.expireIfLessAsync(Duration duration)	Sets a timeout for this object only if it's less than timeout set before.
RFuture<Boolean>	RExpirableAsync.expireIfLessAsync(Instant time)	Sets an expiration date for this object only if it's less than expiration date set before.
RFuture<Boolean>	RExpirableAsync.expireIfNotSetAsync(Duration duration)	Sets a timeout for this object only if it hasn't been set before.
RFuture<Boolean>	RExpirableAsync.expireIfNotSetAsync(Instant time)	Sets an expiration date for this object only if it hasn't been set before.
RFuture<Boolean>	RExpirableAsync.expireIfSetAsync(Duration duration)	Sets a timeout for this object only if it has been already set.
RFuture<Boolean>	RExpirableAsync.expireIfSetAsync(Instant time)	Sets an expiration date for this object only if it has been already set.
RFuture<Boolean>	RMultimapCacheAsync.expireKeyAsync(K key, long timeToLive, TimeUnit timeUnit)	Set a timeout for key in async mode.
RFuture<FastAutoClaimResult>	RStreamAsync.fastAutoClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId startId, int count)	Transfers ownership of pending messages by id to a new consumer by name if idle time of messages and startId are greater than defined value.
RFuture<List<StreamMessageId>>	RStreamAsync.fastClaimAsync(String groupName, String consumerName, long idleTime, TimeUnit idleTimeUnit, StreamMessageId... ids)	Transfers ownership of pending messages by id to a new consumer by name if idle time of messages is greater than defined value.
RFuture<Boolean>	RMapAsync.fastPutAsync(K key, V value)	Stores the specified value mapped by specified key.
RFuture<Boolean>	RMapCacheAsync.fastPutAsync(K key, V value, long ttl, TimeUnit unit)	Stores value mapped by key with specified time to live.
RFuture<Boolean>	RMapCacheAsync.fastPutAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	Stores value mapped by key with specified time to live and max idle time.
RFuture<Boolean>	RMapAsync.fastPutIfAbsentAsync(K key, V value)	Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
RFuture<Boolean>	RMapCacheAsync.fastPutIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	If the specified key is not already associated with a value, associate it with the given value.
RFuture<Boolean>	RMapAsync.fastPutIfExistsAsync(K key, V value)	Stores the specified value mapped by key only if mapping already exists.
RFuture<Void>	RListAsync.fastRemoveAsync(int index)	Removes element at index.
RFuture<Long>	RMapAsync.fastRemoveAsync(K... keys)	Removes map entries mapped by specified keys.
RFuture<Long>	RMultimapAsync.fastRemoveAsync(K... keys)	Removes keys from map by one operation Works faster than RMultimap.remove but not returning the value associated with key
RFuture<Boolean>	RMapAsync.fastReplaceAsync(K key, V value)	Replaces previous value with a new value mapped by specified key.
RFuture<Void>	RListAsync.fastSetAsync(int index, V element)	Set element at index.
RFuture<String>	RLexSortedSetAsync.firstAsync()	Returns the first element.
RFuture<V>	RScoredSortedSetAsync.firstAsync()	Returns the head element or null if this sorted set is empty.
RFuture<V>	RTimeSeriesAsync.firstAsync()	Returns the head element or null if this time-series collection is empty.
RFuture<Collection<V>>	RTimeSeriesAsync.firstAsync(int count)	Returns the head elements of this time-series collection.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.firstEntriesAsync(int count)	Returns the head entries of this time-series collection.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.firstEntryAsync()	Returns the head entry or null if this time-series collection is empty.
RFuture<Double>	RScoredSortedSetAsync.firstScoreAsync()	Returns score of the head element or returns null if this sorted set is empty.
RFuture<Long>	RTimeSeriesAsync.firstTimestampAsync()	Returns timestamp of the head timestamp or null if this time-series collection is empty.
RFuture<Void>	RKeysAsync.flushallAsync()	Delete all keys of all existing databases
RFuture<Void>	RKeysAsync.flushallParallelAsync()	Delete all keys of all existing databases in background without blocking server.
RFuture<Void>	RFunctionAsync.flushAsync()	Deletes all libraries.
RFuture<Void>	RKeysAsync.flushdbAsync()	Delete all keys of currently selected database
RFuture<Void>	RKeysAsync.flushdbParallelAsync()	Delete all keys of currently selected database in background without blocking server.
RFuture<Boolean>	RLockAsync.forceUnlockAsync()	Unlocks the lock independently of its state
RFuture<Map<K,V>>	CacheAsync.getAllAsync(Set<? extends K> keys)	This method accepts a set of requested keys and retrieves a collection of entries from the CacheAsync, returning them as a Map of the associated values.
RFuture<Map<K,V>>	RMapAsync.getAllAsync(Set<K> keys)	Returns map slice contained the mappings with defined keys.
RFuture<Collection<V>>	RMultimapAsync.getAllAsync(K key)
RFuture<Double>	RAtomicDoubleAsync.getAndAddAsync(double delta)	Atomically adds the given value to the current value.
RFuture<Long>	RAtomicLongAsync.getAndAddAsync(long delta)	Atomically adds the given value to the current value.
RFuture<V>	RBucketAsync.getAndClearExpireAsync()	Retrieves current element in the holder and clears expiration date set before.
RFuture<Double>	RAtomicDoubleAsync.getAndDecrementAsync()	Atomically decrements by one the current value.
RFuture<Long>	RAtomicLongAsync.getAndDecrementAsync()	Atomically decrements by one the current value.
RFuture<Double>	RAtomicDoubleAsync.getAndDeleteAsync()	Returns and deletes object
RFuture<Long>	RAtomicLongAsync.getAndDeleteAsync()	Returns and deletes object
RFuture<V>	RBucketAsync.getAndDeleteAsync()	Retrieves element in the holder and removes it.
RFuture<V>	RBucketAsync.getAndExpireAsync(Duration duration)	Retrieves current element in the holder and sets an expiration duration for it.
RFuture<V>	RBucketAsync.getAndExpireAsync(Instant time)	Retrieves current element in the holder and sets an expiration date for it.
RFuture<Double>	RAtomicDoubleAsync.getAndIncrementAsync()	Atomically increments the current value by one.
RFuture<Long>	RAtomicLongAsync.getAndIncrementAsync()	Atomically increments the current value by one.
RFuture<V>	CacheAsync.getAndPutAsync(K key, V value)	This method places the given key and value in the cache.
RFuture<V>	CacheAsync.getAndRemoveAsync(K key)	This method atomically removes the entry for a key only if it is currently mapped to some value.
RFuture<V>	RTimeSeriesAsync.getAndRemoveAsync(long timestamp)	Removes and returns object by specified timestamp.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.getAndRemoveEntryAsync(long timestamp)	Removes and returns entry by specified timestamp.
RFuture<V>	CacheAsync.getAndReplaceAsync(K key, V value)	This method atomically replaces a given key's value if and only if the key is currently mapped to a value.
RFuture<Double>	RAtomicDoubleAsync.getAndSetAsync(double newValue)	Atomically sets the given value and returns the old value.
RFuture<Long>	RAtomicLongAsync.getAndSetAsync(long newValue)	Atomically sets the given value and returns the old value.
RFuture<V>	RBucketAsync.getAndSetAsync(V newValue)	Retrieves current element in the holder and replaces it with newValue.
RFuture<V>	RBucketAsync.getAndSetAsync(V value, long timeToLive, TimeUnit timeUnit)	Retrieves current element in the holder and replaces it with newValue with defined timeToLive interval.
<T> RFuture<T>	RJsonBucketAsync.getAndSetAsync(JsonCodec<T> codec, String path, Object newValue)	Retrieves current value of element specified by JSONPath and replaces it with newValue.
RFuture<V>	CacheAsync.getAsync(K key)	This method retrieves an entry from the cache.
RFuture<Double>	RAtomicDoubleAsync.getAsync()	Returns current value.
RFuture<Long>	RAtomicLongAsync.getAsync()	Returns current value.
RFuture<Boolean>	RBitSetAsync.getAsync(long bitIndex)	Returns true if bit set to one and false overwise.
RFuture<V>	RBucketAsync.getAsync()	Retrieves element stored in the holder.
<V> RFuture<Map<String,V>>	RBucketsAsync.getAsync(String... keys)	Returns Redis object mapped by key.
<T> RFuture<T>	RJsonBucketAsync.getAsync(JsonCodec<T> codec, String... paths)	Get Json object/objects by JSONPath
RFuture<V>	RListAsync.getAsync(int index)	Get element at index
RFuture<List<V>>	RListAsync.getAsync(int... indexes)	Loads elements by specified indexes
RFuture<V>	RMapAsync.getAsync(K key)	Returns the value mapped by defined key or null if value is absent.
RFuture<V>	RTimeSeriesAsync.getAsync(long timestamp)	Returns object by specified timestamp or null if it doesn't exist.
RFuture<Byte>	RBitSetAsync.getByteAsync(long offset)	Returns byte number at specified offset
RFuture<RateLimiterConfig>	RRateLimiterAsync.getConfigAsync()	Returns current configuration of this RateLimiter object.
RFuture<Long>	RCountDownLatchAsync.getCountAsync()	Returns value of current count.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.getEntryAsync(long timestamp)	Returns time series entry by specified timestamp or null if it doesn't exist.
RFuture<Long>	RExpirableAsync.getExpireTimeAsync()	Expiration time of Redisson object that has a timeout
RFuture<Integer>	RLockAsync.getHoldCountAsync()	Number of holds on this lock by the current thread
RFuture<Long>	RObjectAsync.getIdleTimeAsync()	Returns number of seconds spent since last write or read operation over this object.
RFuture<StreamInfo<K,V>>	RStreamAsync.getInfoAsync()	Returns information about this stream.
RFuture<Integer>	RBitSetAsync.getIntegerAsync(long offset)	Returns integer number at specified offset
RFuture<List<String>>	RJsonBucketAsync.getKeysAsync()	Returns list of keys in JSON container
RFuture<List<String>>	RJsonBucketAsync.getKeysAsync(String path)	Returns list of keys in JSON container specified by JSONPath
RFuture<List<List<String>>>	RJsonBucketAsync.getKeysMultiAsync(String path)	Returns list of keys in JSON containers specified by JSONPath
RFuture<V>	RDequeAsync.getLastAsync()	Returns element at the tail of this deque or null if there are no elements in deque.
RFuture<Long>	RBitSetAsync.getLongAsync(long offset)	Returns long number at specified offset
RFuture<PendingResult>	RStreamAsync.getPendingInfoAsync(String groupName)	Returns common info about pending messages by group name.
RFuture<Integer>	RRemoteService.getPendingInvocationsAsync(Class<?> remoteInterface)	Returns pending invocations amount for handling in free workers.
RFuture<List<Double>>	RScoredSortedSetAsync.getScoreAsync(Collection<V> elements)	Returns scores of elements.
RFuture<Double>	RScoredSortedSetAsync.getScoreAsync(V o)	Returns score of element or null if it doesn't exist.
RFuture<Short>	RBitSetAsync.getShortAsync(long offset)	Returns short number at specified offset
RFuture<Long>	RBitSetAsync.getSignedAsync(int size, long offset)	Returns signed number at specified offset and size
RFuture<Integer>	RKeysAsync.getSlotAsync(String key)	Get hash slot identifier for key in async mode.
RFuture<Integer>	RExecutorServiceAsync.getTaskCountAsync()	Returns amount of tasks awaiting execution or currently in execution.
RFuture<Set<String>>	RExecutorServiceAsync.getTaskIdsAsync()	Returns list of task ids awaiting execution or currently in execution.
RFuture<JsonType>	RJsonBucketAsync.getTypeAsync()	Returns type of element
RFuture<JsonType>	RJsonBucketAsync.getTypeAsync(String path)	Returns type of element specified by JSONPath
RFuture<RType>	RKeysAsync.getTypeAsync(String key)	Get Redis object type by key
RFuture<Long>	RBitSetAsync.getUnsignedAsync(int size, long offset)	Returns unsigned number at specified offset and size
RFuture<V>	RMapCacheAsync.getWithTTLOnlyAsync(K key)	Returns the value mapped by defined key or null if value is absent.
RFuture<Map<V,String>>	RGeoAsync.hashAsync(V... members)	Returns 11 characters Geohash string mapped by defined member.
RFuture<Boolean>	RExecutorServiceAsync.hasTaskAsync(String taskId)	Returns true if this Executor Service has task by taskId awaiting execution or currently in execution
RFuture<Double>	RAtomicDoubleAsync.incrementAndGetAsync()	Atomically increments the current value by one.
RFuture<Long>	RAtomicLongAsync.incrementAndGetAsync()	Atomically increments the current value by one.
<T extends Number> RFuture<T>	RJsonBucketAsync.incrementAndGetAsync(String path, T delta)	Increments the current value specified by JSONPath by delta.
RFuture<Byte>	RBitSetAsync.incrementAndGetByteAsync(long offset, byte increment)	Increments current byte value on defined increment value at specified offset and returns result.
RFuture<Integer>	RBitSetAsync.incrementAndGetIntegerAsync(long offset, int increment)	Increments current integer value on defined increment value at specified offset and returns result.
RFuture<Long>	RBitSetAsync.incrementAndGetLongAsync(long offset, long increment)	Increments current long value on defined increment value at specified offset and returns result.
<T extends Number> RFuture<List<T>>	RJsonBucketAsync.incrementAndGetMultiAsync(String path, T delta)	Increments the current values specified by JSONPath by delta.
RFuture<Short>	RBitSetAsync.incrementAndGetShortAsync(long offset, short increment)	Increments current short value on defined increment value at specified offset and returns result.
RFuture<Long>	RBitSetAsync.incrementAndGetSignedAsync(int size, long offset, long increment)	Increments current signed value by defined increment value and size at specified offset and returns result.
RFuture<Long>	RBitSetAsync.incrementAndGetUnsignedAsync(int size, long offset, long increment)	Increments current unsigned value by defined increment value and size at specified offset and returns result.
RFuture<Integer>	RListAsync.indexOfAsync(Object element)	Returns last index of element or -1 if element isn't found
RFuture<Map<String,String>>	NodeAsync.infoAsync(Node.InfoSection section)	Deprecated.
RFuture<Integer>	RScoredSortedSetAsync.intersectionAsync(String... names)	Intersect provided ScoredSortedSets and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.intersectionAsync(Map<String,Double> nameWithWeight)	Intersect provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.intersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)	Intersect provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.intersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)	Intersect provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
RFuture<Integer>	RSetAsync.intersectionAsync(String... names)	Intersection sets specified by name and write to current set.
RFuture<Boolean>	RObjectAsync.isExistsAsync()	Check object existence in async mode.
RFuture<Boolean>	RLockAsync.isLockedAsync()	Checks if the lock locked by any thread
RFuture<Integer>	RMultimapAsync.keySizeAsync()	Returns the number of key-value pairs in this multimap.
RFuture<Void>	RFunctionAsync.killAsync()	Kills currently executed functions.
RFuture<String>	RLexSortedSetAsync.lastAsync()	Returns the last element.
RFuture<V>	RScoredSortedSetAsync.lastAsync()	Returns the tail element or null if this sorted set is empty.
RFuture<V>	RTimeSeriesAsync.lastAsync()	Returns the tail element or null if this time-series collection is empty.
RFuture<Collection<V>>	RTimeSeriesAsync.lastAsync(int count)	Returns the tail elements of this time-series collection.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.lastEntriesAsync(int count)	Returns the tail entries of this time-series collection.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.lastEntryAsync()	Returns the tail entry or null if this time-series collection is empty.
RFuture<Integer>	RListAsync.lastIndexOfAsync(Object element)	Returns last index of element or -1 if element isn't found
RFuture<Double>	RScoredSortedSetAsync.lastScoreAsync()	Returns score of the tail element or returns null if this sorted set is empty.
RFuture<Long>	RTimeSeriesAsync.lastTimestampAsync()	Returns timestamp of the tail element or null if this time-series collection is empty.
RFuture<Long>	RBitSetAsync.lengthAsync()	Returns "logical size" = index of highest set bit plus one.
RFuture<List<FunctionLibrary>>	RFunctionAsync.listAsync()	Returns information about libraries and functions per each.
RFuture<List<FunctionLibrary>>	RFunctionAsync.listAsync(String namePattern)	Returns information about libraries and functions per each by name pattern.
RFuture<List<StreamConsumer>>	RStreamAsync.listConsumersAsync(String groupName)	Returns list of objects with information about group customers for specified groupName.
RFuture<List<StreamGroup>>	RStreamAsync.listGroupsAsync()	Returns list of objects with information about groups belonging to this stream.
RFuture<List<PendingEntry>>	RStreamAsync.listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count)	Returns list of common info about pending messages by group and consumer name.
RFuture<List<PendingEntry>>	RStreamAsync.listPendingAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)	Returns list of common info about pending messages by group and consumer name.
RFuture<List<PendingEntry>>	RStreamAsync.listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, int count)	Returns list of common info about pending messages by group name.
RFuture<List<PendingEntry>>	RStreamAsync.listPendingAsync(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)	Returns list of common info about pending messages by group name.
RFuture<Void>	RMapAsync.loadAllAsync(boolean replaceExistingValues, int parallelism)	Loads all map entries to this Redis map using MapLoader.
RFuture<Void>	RMapAsync.loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)	Loads map entries using MapLoader whose keys are listed in defined keys parameter.
RFuture<Void>	RFunctionAsync.loadAndReplaceAsync(String libraryName, String code)	Loads a library and overwrites existing library.
RFuture<Void>	RFunctionAsync.loadAsync(String libraryName, String code)	Loads a library.
RFuture<Void>	RLockAsync.lockAsync()	Acquires the lock.
RFuture<Void>	RLockAsync.lockAsync(long threadId)	Acquires the lock by thread with defined threadId.
RFuture<Void>	RLockAsync.lockAsync(long leaseTime, TimeUnit unit)	Acquires the lock with defined leaseTime.
RFuture<Void>	RLockAsync.lockAsync(long leaseTime, TimeUnit unit, long threadId)	Acquires the lock with defined leaseTime and threadId.
RFuture<V>	RMapAsync.mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)	Associates specified key with the given value if key isn't already associated with a value.
RFuture<Void>	RHyperLogLogAsync.mergeWithAsync(String... otherLogNames)	Merges multiple instances into this instance.
RFuture<Void>	RKeysAsync.migrateAsync(String name, String host, int port, int database, long timeout)	Transfer object from source Redis instance to destination Redis instance
RFuture<Void>	RObjectAsync.migrateAsync(String host, int port, int database, long timeout)	Transfer object from source Redis instance to destination Redis instance in async mode
RFuture<V>	RBlockingDequeAsync.moveAsync(Duration timeout, DequeMoveArgs args)
RFuture<V>	RDequeAsync.moveAsync(DequeMoveArgs args)	Move element from this deque to the given destination deque.
RFuture<Boolean>	RKeysAsync.moveAsync(String name, int database)	Move object to another database
RFuture<Boolean>	RObjectAsync.moveAsync(int database)	Move object to another database in async mode
RFuture<Boolean>	RSetAsync.moveAsync(String destination, V member)	Move a member from this set to the given destination set in async mode.
RFuture<Long>	RIdGeneratorAsync.nextIdAsync()	Returns next unique number but not monotonically increased
RFuture<Void>	RBitSetAsync.notAsync()	Executes NOT operation over all bits
RFuture<Boolean>	RBoundedBlockingQueueAsync.offerAsync(V e, long timeout, TimeUnit unit)	Inserts the specified element into this queue, waiting up to the specified wait time if necessary for space to become available.
RFuture<Void>	RDelayedQueue.offerAsync(V e, long delay, TimeUnit timeUnit)	Inserts element into this queue with specified transfer delay to destination queue.
RFuture<Boolean>	RQueueAsync.offerAsync(V e)	Inserts the specified element into this queue.
RFuture<Boolean>	RDequeAsync.offerFirstAsync(V e)	Adds element at the head of this deque.
RFuture<Boolean>	RDequeAsync.offerLastAsync(V e)	Adds element at the tail of this deque.
RFuture<Void>	RBitSetAsync.orAsync(String... bitSetNames)	Executes OR operation over this object and specified bitsets.
RFuture<V>	RQueueAsync.peekAsync()	Retrieves the head of this queue in async mode.
RFuture<V>	RDequeAsync.peekFirstAsync()	Returns element at the head of this deque or null if there are no elements in deque.
RFuture<V>	RDequeAsync.peekLastAsync()	Returns element at the tail of this deque or null if there are no elements in deque.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.pendingRangeAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, int count)	Returns stream data of pending messages by group and customer name.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.pendingRangeAsync(String groupName, String consumerName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)	Returns stream data of pending messages by group and customer name.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.pendingRangeAsync(String groupName, StreamMessageId startId, StreamMessageId endId, int count)	Returns stream data of pending messages by group name.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.pendingRangeAsync(String groupName, StreamMessageId startId, StreamMessageId endId, long idleTime, TimeUnit idleTimeUnit, int count)	Returns stream data of pending messages by group name.
RFuture<Boolean>	NodeAsync.pingAsync()	Deprecated.
RFuture<Boolean>	NodeAsync.pingAsync(long timeout, TimeUnit timeUnit)	Deprecated. Ping Redis node with specified timeout.
RFuture<V>	RBlockingQueueAsync.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.
RFuture<V>	RQueueAsync.pollAsync()	Retrieves and removes the head of this queue in async mode.
RFuture<List<V>>	RQueueAsync.pollAsync(int limit)	Retrieves and removes the head elements of this queue.
RFuture<V>	RBlockingDequeAsync.pollFirstAsync(long timeout, TimeUnit unit)	Retrieves and removes value at the head of queue.
RFuture<V>	RDequeAsync.pollFirstAsync()	Retrieves and removes element at the head of this deque.
RFuture<List<V>>	RDequeAsync.pollFirstAsync(int limit)	Retrieves and removes the head elements of this queue.
RFuture<String>	RLexSortedSetAsync.pollFirstAsync()	Removes and returns the head element or null if this sorted set is empty.
RFuture<V>	RScoredSortedSetAsync.pollFirstAsync()	Removes and returns the head element or null if this sorted set is empty.
RFuture<Collection<V>>	RScoredSortedSetAsync.pollFirstAsync(int count)	Removes and returns the head elements of this sorted set.
RFuture<V>	RScoredSortedSetAsync.pollFirstAsync(long timeout, TimeUnit unit)	Removes and returns the head element or null if this sorted set is empty.
RFuture<List<V>>	RScoredSortedSetAsync.pollFirstAsync(Duration duration, int count)	Removes and returns the head elements.
RFuture<V>	RTimeSeriesAsync.pollFirstAsync()	Removes and returns the head element or null if this time-series collection is empty.
RFuture<Collection<V>>	RTimeSeriesAsync.pollFirstAsync(int count)	Removes and returns the head elements
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.pollFirstEntriesAsync(int count)	Removes and returns head entries
RFuture<Map<String,Map<V,Double>>>	RScoredSortedSetAsync.pollFirstEntriesFromAnyAsync(int count, String... queueNames)	Removes and returns first available head elements of any sorted set including this one.
RFuture<Map<String,Map<V,Double>>>	RScoredSortedSetAsync.pollFirstEntriesFromAnyAsync(Duration duration, int count, String... queueNames)	Removes and returns first available head elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.pollFirstEntryAsync()	Removes and returns head entry or null if this time-series collection is empty.
RFuture<V>	RBlockingDequeAsync.pollFirstFromAnyAsync(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 own.
RFuture<Map<String,List<V>>>	RBlockingQueueAsync.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.
RFuture<List<V>>	RScoredSortedSetAsync.pollFirstFromAnyAsync(int count, String... queueNames)	Removes and returns first available head elements of any sorted set including this one.
RFuture<V>	RScoredSortedSetAsync.pollFirstFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)	Removes and returns first available head element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
RFuture<List<V>>	RScoredSortedSetAsync.pollFirstFromAnyAsync(Duration duration, int count, String... queueNames)	Removes and returns first available head elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
RFuture<V>	RBlockingQueueAsync.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.
RFuture<V>	RBlockingQueueAsync.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.
RFuture<V>	RQueueAsync.pollLastAndOfferFirstToAsync(String queueName)	Retrieves and removes last available tail element of this queue queue and adds it at the head of queueName.
RFuture<V>	RBlockingDequeAsync.pollLastAsync(long timeout, TimeUnit unit)	Retrieves and removes value at the tail of queue.
RFuture<V>	RDequeAsync.pollLastAsync()	Retrieves and removes element at the tail of this deque.
RFuture<List<V>>	RDequeAsync.pollLastAsync(int limit)	Retrieves and removes the tail elements of this queue.
RFuture<String>	RLexSortedSetAsync.pollLastAsync()	Removes and returns the tail element or null if this sorted set is empty.
RFuture<V>	RScoredSortedSetAsync.pollLastAsync()	Removes and returns the tail element or null if this sorted set is empty.
RFuture<Collection<V>>	RScoredSortedSetAsync.pollLastAsync(int count)	Removes and returns the tail elements of this sorted set.
RFuture<V>	RScoredSortedSetAsync.pollLastAsync(long timeout, TimeUnit unit)	Removes and returns the tail element or null if this sorted set is empty.
RFuture<List<V>>	RScoredSortedSetAsync.pollLastAsync(Duration duration, int count)	Removes and returns the tail elements.
RFuture<V>	RTimeSeriesAsync.pollLastAsync()	Removes and returns the tail element or null if this time-series collection is empty.
RFuture<Collection<V>>	RTimeSeriesAsync.pollLastAsync(int count)	Removes and returns the tail elements or null if this time-series collection is empty.
RFuture<Collection<TimeSeriesEntry<V,L>>>	RTimeSeriesAsync.pollLastEntriesAsync(int count)	Removes and returns tail entries
RFuture<Map<String,Map<V,Double>>>	RScoredSortedSetAsync.pollLastEntriesFromAnyAsync(int count, String... queueNames)	Removes and returns first available tail entries of any sorted set including this one.
RFuture<Map<String,Map<V,Double>>>	RScoredSortedSetAsync.pollLastEntriesFromAnyAsync(Duration duration, int count, String... queueNames)	Removes and returns first available tail entries of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
RFuture<TimeSeriesEntry<V,L>>	RTimeSeriesAsync.pollLastEntryAsync()	Removes and returns the tail entry or null if this time-series collection is empty.
RFuture<V>	RBlockingDequeAsync.pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)	Retrieves and removes first available tail 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 own.
RFuture<Map<String,List<V>>>	RBlockingQueueAsync.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.
RFuture<List<V>>	RScoredSortedSetAsync.pollLastFromAnyAsync(int count, String... queueNames)	Removes and returns first available tail elements of any sorted set including this one.
RFuture<V>	RScoredSortedSetAsync.pollLastFromAnyAsync(long timeout, TimeUnit unit, String... queueNames)	Removes and returns first available tail element of any sorted set, waiting up to the specified wait time if necessary for an element to become available in any of defined sorted sets including this one.
RFuture<List<V>>	RScoredSortedSetAsync.pollLastFromAnyAsync(Duration duration, int count, String... queueNames)	Removes and returns first available tail elements of any sorted set, waiting up to the specified wait time if necessary for elements to become available in any of defined sorted sets including this one.
RFuture<V>	RDequeAsync.popAsync()	Retrieves and removes element at the head of this deque.
RFuture<Map<V,GeoPosition>>	RGeoAsync.posAsync(V... members)	Returns geo-position mapped by defined member.
RFuture<Long>	RReliableTopicAsync.publishAsync(Object message)	Publish the message to all subscribers of this topic asynchronously.
RFuture<Long>	RTopicAsync.publishAsync(Object message)	Publish the message to all subscribers of this topic asynchronously
RFuture<Void>	RDequeAsync.pushAsync(V e)	Adds element at the head of this deque.
RFuture<Void>	CacheAsync.putAllAsync(Map<? extends K,? extends V> map)	This method copies all of the entries from the given Map to the CacheAsync.
RFuture<Void>	RMapAsync.putAllAsync(Map<? extends K,? extends V> map)	Stores map entries specified in map object in batch mode.
RFuture<Void>	RMapAsync.putAllAsync(Map<? extends K,? extends V> map, int batchSize)	Stores map entries specified in map object in batch mode.
RFuture<Void>	RMapCacheAsync.putAllAsync(Map<? extends K,? extends V> map, long ttl, TimeUnit ttlUnit)	Associates the specified value with the specified key in batch.
RFuture<Boolean>	RMultimapAsync.putAllAsync(K key, Iterable<? extends V> values)	Stores a key-value pair in this multimap for each of values, all using the same key, key.
RFuture<Void>	CacheAsync.putAsync(K key, V value)	This method places the given value V in the cache and associates it with the given key K.
RFuture<Void>	RBlockingQueueAsync.putAsync(V e)	Inserts the specified element into this queue in async mode, waiting if necessary for space to become available.
RFuture<V>	RMapAsync.putAsync(K key, V value)	Stores the specified value mapped by specified key.
RFuture<V>	RMapCacheAsync.putAsync(K key, V value, long ttl, TimeUnit unit)	Stores value mapped by key with specified time to live.
RFuture<V>	RMapCacheAsync.putAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	Stores value mapped by key with specified time to live and max idle time.
RFuture<Boolean>	RMultimapAsync.putAsync(K key, V value)	Stores a key-value pair in this multimap.
RFuture<Void>	RBlockingDequeAsync.putFirstAsync(V e)	Adds value to the head of queue.
RFuture<Boolean>	CacheAsync.putIfAbsentAsync(K key, V value)	This method places the given key and value in the cache atomically, if the key is not already associated with a value in the cache.
RFuture<V>	RMapAsync.putIfAbsentAsync(K key, V value)	Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
RFuture<V>	RMapCacheAsync.putIfAbsentAsync(K key, V value, long ttl, TimeUnit unit)	If the specified key is not already associated with a value, associate it with the given value.
RFuture<V>	RMapCacheAsync.putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	If the specified key is not already associated with a value, associate it with the given value.
RFuture<V>	RMapAsync.putIfExistsAsync(K key, V value)	Stores the specified value mapped by key only if mapping already exists.
RFuture<Void>	RBlockingDequeAsync.putLastAsync(V e)	Adds value to the tail of queue.
RFuture<List<V>>	RGeoAsync.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(V member, double radius, GeoUnit geoUnit)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(V member, double radius, GeoUnit geoUnit, int count)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)	Deprecated.
RFuture<List<V>>	RGeoAsync.radiusAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit)
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit, int count)
RFuture<Long>	RGeoAsync.radiusStoreSortedToAsync(String destName, V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, int count)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit, int count)	Deprecated.
RFuture<Long>	RGeoAsync.radiusStoreToAsync(String destName, V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)	Deprecated.
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,Double>>	RGeoAsync.radiusWithDistanceAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(double longitude, double latitude, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, int count)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder)
RFuture<Map<V,GeoPosition>>	RGeoAsync.radiusWithPositionAsync(V member, double radius, GeoUnit geoUnit, GeoOrder geoOrder, int count)
RFuture<V>	RScoredSortedSetAsync.randomAsync()	Returns random element from this sorted set
RFuture<Collection<V>>	RScoredSortedSetAsync.randomAsync(int count)	Returns random elements from this sorted set limited by count
RFuture<V>	RSetAsync.randomAsync()	Returns random element from set in async mode
RFuture<Set<V>>	RSetAsync.randomAsync(int count)	Returns random elements from set limited by count
RFuture<Map<K,V>>	RMapAsync.randomEntriesAsync(int count)	Returns random map entries from this map limited by count
RFuture<Map<V,Double>>	RScoredSortedSetAsync.randomEntriesAsync(int count)	Returns random entries from this sorted set limited by count.
RFuture<String>	RKeysAsync.randomKeyAsync()	Get random key in async mode
RFuture<Set<K>>	RMapAsync.randomKeysAsync(int count)	Returns random keys from this map limited by count
RFuture<Collection<String>>	RLexSortedSetAsync.rangeAsync(int startIndex, int endIndex)	Returns values by rank range.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)	Returns values range starting with fromElement and ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count)	Returns values range starting with fromElement and ending with toElement.
RFuture<List<V>>	RListAsync.rangeAsync(int toIndex)	Returns range of values from 0 index to toIndex.
RFuture<List<V>>	RListAsync.rangeAsync(int fromIndex, int toIndex)	Returns range of values from fromIndex to toIndex index including.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.rangeAsync(int count, StreamMessageId startId, StreamMessageId endId)	Returns stream data in range by specified start Stream ID (included) and end Stream ID (included).
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.rangeAsync(StreamMessageId startId, StreamMessageId endId)	Returns stream data in range by specified start Stream ID (included) and end Stream ID (included).
RFuture<Collection<V>>	RTimeSeriesAsync.rangeAsync(long startTimestamp, long endTimestamp)	Returns ordered elements of this time-series collection within timestamp range.
RFuture<Collection<V>>	RTimeSeriesAsync.rangeAsync(long startTimestamp, long endTimestamp, int limit)	Returns ordered elements of this time-series collection within timestamp range.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeHeadAsync(String toElement, boolean toInclusive)	Returns head values range ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeHeadAsync(String toElement, boolean toInclusive, int offset, int count)	Returns head values range ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeHeadReversedAsync(String toElement, boolean toInclusive)	Returns head values range in reverse order ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeHeadReversedAsync(String toElement, boolean toInclusive, int offset, int count)	Returns head values range in reverse order ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeReversedAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)	Returns values range in reverse order starting with fromElement and ending with toElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeReversedAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive, int offset, int count)	Returns values range in reverse order starting with fromElement and ending with toElement.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.rangeReversedAsync(int count, StreamMessageId startId, StreamMessageId endId)	Returns stream data in reverse order in range by specified start Stream ID (included) and end Stream ID (included).
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.rangeReversedAsync(StreamMessageId startId, StreamMessageId endId)	Returns stream data in reverse order in range by specified start Stream ID (included) and end Stream ID (included).
RFuture<Collection<V>>	RTimeSeriesAsync.rangeReversedAsync(long startTimestamp, long endTimestamp)	Returns elements of this time-series collection in reverse order within timestamp range.
RFuture<Collection<V>>	RTimeSeriesAsync.rangeReversedAsync(long startTimestamp, long endTimestamp, int limit)	Returns elements of this time-series collection in reverse order within timestamp range.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeTailAsync(String fromElement, boolean fromInclusive)	Returns tail values range starting with fromElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeTailAsync(String fromElement, boolean fromInclusive, int offset, int count)	Returns tail values range starting with fromElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeTailReversedAsync(String fromElement, boolean fromInclusive)	Returns tail values range in reverse order starting with fromElement.
RFuture<Collection<String>>	RLexSortedSetAsync.rangeTailReversedAsync(String fromElement, boolean fromInclusive, int offset, int count)	Returns tail values range in reverse order starting with fromElement.
RFuture<Integer>	RScoredSortedSetAsync.rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Stores to defined ScoredSortedSet values between startScore and endScore.
RFuture<Integer>	RScoredSortedSetAsync.rangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Stores to defined ScoredSortedSet values between startScore and endScore.
RFuture<Integer>	RScoredSortedSetAsync.rangeToAsync(String destName, int startIndex, int endIndex)	Stores to defined ScoredSortedSet values by rank range.
RFuture<Integer>	RLexSortedSetAsync.rankAsync(String o)	Returns rank of the element
RFuture<Integer>	RScoredSortedSetAsync.rankAsync(V o)	Returns rank of value, with the scores ordered from low to high.
RFuture<Collection<String>>	RLexSortedSetAsync.readAllAsync()	Read all values at once.
RFuture<List<V>>	RListAsync.readAllAsync()	Read all elements at once
RFuture<List<V>>	RQueueAsync.readAllAsync()	Returns all queue elements at once
RFuture<Collection<V>>	RScoredSortedSetAsync.readAllAsync()	Read all values at once.
RFuture<Set<V>>	RSetAsync.readAllAsync()	Read all elements at once
RFuture<Set<V>>	RSetCacheAsync.readAllAsync()	Read all elements at once
RFuture<Collection<V>>	RSortedSet.readAllAsync()
RFuture<Set<Map.Entry<K,V>>>	RMapAsync.readAllEntrySetAsync()	Read all map entries at once
RFuture<Set<K>>	RMapAsync.readAllKeySetAsync()	Read all keys at once
RFuture<Set<K>>	RMultimapAsync.readAllKeySetAsync()	Read all keys at once
RFuture<Map<K,V>>	RMapAsync.readAllMapAsync()	Read all map as local instance at once
RFuture<Collection<V>>	RMapAsync.readAllValuesAsync()	Read all values at once
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId... ids)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Deprecated.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readAsync(int count, StreamMessageId... ids)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, StreamMessageId id, String name2, StreamMessageId id2)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(int count, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Deprecated.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readAsync(long timeout, TimeUnit unit, StreamMessageId... ids)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(long timeout, TimeUnit unit, StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(StreamMultiReadArgs args)	Read stream data from multiple streams including current.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readAsync(StreamReadArgs args)	Read stream data from current stream only.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readAsync(StreamMessageId... ids)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(StreamMessageId id, String name2, StreamMessageId id2)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(StreamMessageId id, String name2, StreamMessageId id2, String name3, StreamMessageId id3)	Deprecated.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readAsync(StreamMessageId id, Map<String,StreamMessageId> nameToId)	Deprecated.
RFuture<Collection<V>>	RScoredSortedSetAsync.readDiffAsync(String... names)	Diff ScoredSortedSets specified by name with current ScoredSortedSet without state change.
RFuture<Set<V>>	RSetAsync.readDiffAsync(String... names)	Diff sets specified by name with current set.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId... ids)	Read stream data from groupName by consumerName and specified collection of Stream IDs.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId... ids)	Read stream data from groupName by consumerName and specified collection of Stream IDs.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, int count, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId... ids)	Read stream data from groupName by consumerName and specified collection of Stream IDs.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, long timeout, TimeUnit unit, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamMultiReadGroupArgs args)	Read stream data from consumer group and multiple streams including current.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamReadGroupArgs args)	Read stream data from consumer group and current stream only.
RFuture<Map<StreamMessageId,Map<K,V>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamMessageId... ids)	Read stream data from groupName by consumerName and specified collection of Stream IDs.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamMessageId id, String key2, StreamMessageId id2, String key3, StreamMessageId id3)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Map<String,Map<StreamMessageId,Map<K,V>>>>	RStreamAsync.readGroupAsync(String groupName, String consumerName, StreamMessageId id, Map<String,StreamMessageId> nameToId)	Read stream data from groupName by consumerName, starting by specified message ids for this and other streams.
RFuture<Collection<V>>	RScoredSortedSetAsync.readIntersectionAsync(String... names)	Intersect provided ScoredSortedSets with current ScoredSortedSet without state change
RFuture<Collection<V>>	RScoredSortedSetAsync.readIntersectionAsync(Map<String,Double> nameWithWeight)	Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet without state change
RFuture<Collection<V>>	RScoredSortedSetAsync.readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, String... names)	Intersect provided ScoredSortedSets with current ScoredSortedSet using defined aggregation method without state change
RFuture<Collection<V>>	RScoredSortedSetAsync.readIntersectionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)	Intersect provided ScoredSortedSets mapped to weight multiplier with current ScoredSortedSet using defined aggregation method without state change
RFuture<Set<V>>	RSetAsync.readIntersectionAsync(String... names)	Intersection sets specified by name with current set.
<T> RFuture<Collection<T>>	RSortableAsync.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)	Read data in sorted view lexicographically
<T> RFuture<Collection<T>>	RSortableAsync.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)	Read data in sorted view lexicographically
RFuture<V>	RSortableAsync.readSortAlphaAsync(String byPattern, SortOrder order)	Read data in sorted view lexicographically
RFuture<V>	RSortableAsync.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)	Read data in sorted view lexicographically
RFuture<V>	RSortableAsync.readSortAlphaAsync(SortOrder order)	Read data in sorted view lexicographically
RFuture<V>	RSortableAsync.readSortAlphaAsync(SortOrder order, int offset, int count)	Read data in sorted view lexicographically
<T> RFuture<Collection<T>>	RSortableAsync.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order)	Read data in sorted view
<T> RFuture<Collection<T>>	RSortableAsync.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)	Read data in sorted view
RFuture<V>	RSortableAsync.readSortAsync(String byPattern, SortOrder order)	Read data in sorted view
RFuture<V>	RSortableAsync.readSortAsync(String byPattern, SortOrder order, int offset, int count)	Read data in sorted view
RFuture<V>	RSortableAsync.readSortAsync(SortOrder order)	Read data in sorted view
RFuture<V>	RSortableAsync.readSortAsync(SortOrder order, int offset, int count)	Read data in sorted view
RFuture<Collection<V>>	RScoredSortedSetAsync.readUnionAsync(String... names)	Union ScoredSortedSets specified by name with current ScoredSortedSet without state change.
RFuture<Collection<V>>	RScoredSortedSetAsync.readUnionAsync(Map<String,Double> nameWithWeight)	Union provided ScoredSortedSets mapped to weight multiplier and current ScoredSortedSet without state change.
RFuture<Collection<V>>	RScoredSortedSetAsync.readUnionAsync(RScoredSortedSet.Aggregate aggregate, String... names)	Union ScoredSortedSets specified by name with defined aggregation method and current ScoredSortedSet without state change.
RFuture<Collection<V>>	RScoredSortedSetAsync.readUnionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)	Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and current ScoredSortedSet without state change
RFuture<Set<V>>	RSetAsync.readUnionAsync(String... names)	Union sets specified by name with current set.
RFuture<Void>	RPermitExpirableSemaphoreAsync.releaseAsync(String permitId)	Releases a permit by its id.
RFuture<Void>	RSemaphoreAsync.releaseAsync()	Releases a permit.
RFuture<Void>	RSemaphoreAsync.releaseAsync(int permits)	Releases defined amount of permits.
RFuture<Integer>	RRingBufferAsync.remainingCapacityAsync()	Returns remaining capacity of this queue
RFuture<Long>	RExpirableAsync.remainTimeToLiveAsync()	Remaining time to live of Redisson object that has a timeout
RFuture<Long>	RKeysAsync.remainTimeToLiveAsync(String name)	Remaining time to live of Redisson object that has a timeout
RFuture<Long>	RLockAsync.remainTimeToLiveAsync()	Remaining time to live of the lock
RFuture<Long>	RMapCacheAsync.remainTimeToLiveAsync(K key)	Remaining time to live of map entry associated with a key.
RFuture<Void>	CacheAsync.removeAllAsync(Set<? extends K> keys)	This method deletes the entries for the given keys.
RFuture<Boolean>	RCollectionAsync.removeAllAsync(Collection<?> c)	Removes all of this collection's elements that are also contained in the specified collection.
RFuture<Collection<V>>	RMultimapAsync.removeAllAsync(Object key)	Removes all values associated with the key key.
RFuture<Boolean>	RScoredSortedSetAsync.removeAllAsync(Collection<?> c)	Removes all of this sorted set's elements that are also contained in the specified collection.
RFuture<Integer>	RSetAsync.removeAllCountedAsync(Collection<? extends V> c)	Removes all elements contained in the specified collection.
RFuture<Void>	RPatternTopic.removeAllListenersAsync()	Removes all listeners from this topic
RFuture<Void>	RReliableTopicAsync.removeAllListenersAsync()	Removes all listeners attached to this topic instance
RFuture<Void>	RTopicAsync.removeAllListenersAsync()	Removes all listeners from this topic
RFuture<Boolean>	CacheAsync.removeAsync(K key)	This method deletes the mapping for a given key from the cache, if it is present.
RFuture<Boolean>	CacheAsync.removeAsync(K key, V oldValue)	This method atomically removes a key's mapping only if it is currently mapped to the provided value.
RFuture<Boolean>	RCollectionAsync.removeAsync(Object o)	Removes a single instance of the specified element from this collection, if it is present.
RFuture<V>	RListAsync.removeAsync(int index)	Removes element at index.
RFuture<Boolean>	RListAsync.removeAsync(Object element, int count)	Removes up to count occurrences of element
RFuture<Boolean>	RMapAsync.removeAsync(Object key, Object value)	Removes map entry only if it exists with specified key and value.
RFuture<V>	RMapAsync.removeAsync(K key)	Removes map entry by specified key and returns value.
RFuture<Boolean>	RMultimapAsync.removeAsync(Object key, Object value)	Removes a single key-value pair with the key key and the value value from this multimap, if such exists.
RFuture<Boolean>	RScoredSortedSetAsync.removeAsync(V o)	Removes a single instance of the specified element from this sorted set, if it is present.
RFuture<Boolean>	RSortedSet.removeAsync(Object value)
RFuture<Long>	RStreamAsync.removeAsync(StreamMessageId... ids)	Removes messages by id.
RFuture<Boolean>	RTimeSeriesAsync.removeAsync(long timestamp)	Removes object by specified timestamp.
RFuture<Long>	RStreamAsync.removeConsumerAsync(String groupName, String consumerName)	Removes consumer of the group by name.
RFuture<V>	RDequeAsync.removeFirstAsync()	Retrieves and removes the first element of deque.
RFuture<Boolean>	RDequeAsync.removeFirstOccurrenceAsync(Object o)	Removes first occurrence of element o
RFuture<Void>	RStreamAsync.removeGroupAsync(String groupName)	Removes group by name.
RFuture<V>	RDequeAsync.removeLastAsync()	Retrieves and removes the last element of deque.
RFuture<Boolean>	RDequeAsync.removeLastOccurrenceAsync(Object o)	Removes last occurrence of element o
RFuture<Void>	RObjectAsync.removeListenerAsync(int listenerId)	Removes object event listener
RFuture<Void>	RPatternTopic.removeListenerAsync(int listenerId)
RFuture<Void>	RReliableTopicAsync.removeListenerAsync(String... listenerIds)	Removes the listener by id attached to this topic instance
RFuture<Void>	RTopicAsync.removeListenerAsync(Integer... listenerIds)	Removes the listener by id for listening this topic
RFuture<Void>	RTopicAsync.removeListenerAsync(MessageListener<?> listener)	Removes the listener by its instance
RFuture<V>	RSetAsync.removeRandomAsync()	Removes and returns random element from set in async mode
RFuture<Set<V>>	RSetAsync.removeRandomAsync(int amount)	Removes and returns random elements from set in async mode
RFuture<Integer>	RLexSortedSetAsync.removeRangeAsync(String fromElement, boolean fromInclusive, String toElement, boolean toInclusive)	Removes values range starting with fromElement and ending with toElement.
RFuture<Integer>	RTimeSeriesAsync.removeRangeAsync(long startTimestamp, long endTimestamp)	Removes values within timestamp range.
RFuture<Integer>	RScoredSortedSetAsync.removeRangeByRankAsync(int startIndex, int endIndex)	Removes values by rank range.
RFuture<Integer>	RScoredSortedSetAsync.removeRangeByScoreAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Removes values by score range.
RFuture<Integer>	RLexSortedSetAsync.removeRangeHeadAsync(String toElement, boolean toInclusive)	Removes head values range ending with toElement.
RFuture<Integer>	RLexSortedSetAsync.removeRangeTailAsync(String fromElement, boolean fromInclusive)	Removes tail values range starting with fromElement.
RFuture<Void>	RKeysAsync.renameAsync(String currentName, String newName)	Rename current object key to newName
RFuture<Void>	RObjectAsync.renameAsync(String newName)	Rename current object key to newName in async mode
RFuture<Boolean>	RKeysAsync.renamenxAsync(String oldName, String newName)	Rename object with oldName to newName only if new key is not exists
RFuture<Boolean>	RObjectAsync.renamenxAsync(String newName)	Rename current object key to newName in async mode only if new key is not exists
RFuture<Boolean>	CacheAsync.replaceAsync(K key, V value)	This method atomically replaces an entry only if the key is currently mapped to some value.
RFuture<Boolean>	CacheAsync.replaceAsync(K key, V oldValue, V newValue)	This method atomically replaces an entry only if the key is currently mapped to a given value.
RFuture<V>	RMapAsync.replaceAsync(K key, V value)	Replaces previous value with a new value mapped by specified key.
RFuture<Boolean>	RMapAsync.replaceAsync(K key, V oldValue, V newValue)	Replaces previous oldValue with a newValue mapped by specified key.
RFuture<Boolean>	RScoredSortedSetAsync.replaceAsync(V oldObject, V newObject)	Replaces a previous oldObject with a newObject.
RFuture<Collection<V>>	RMultimapAsync.replaceValuesAsync(K key, Iterable<? extends V> values)	Stores a collection of values with the same key, replacing any existing values for that key.
RFuture<Void>	RDoubleAdder.resetAsync()	Resets value across all RDoubleAdder instances
RFuture<Void>	RDoubleAdder.resetAsync(long timeout, TimeUnit timeUnit)	Resets value across all RDoubleAdder instances within defined timeout.
RFuture<Void>	RLongAdder.resetAsync()	Resets value across all RLongAdder instances
RFuture<Void>	RLongAdder.resetAsync(long timeout, TimeUnit timeUnit)	Resets value across all RLongAdder instances within defined timeout.
RFuture<Void>	RFunctionAsync.restoreAfterFlushAsync(byte[] payload)	Restores libraries using their state returned by RFunctionAsync.dumpAsync() method.
RFuture<Void>	RFunctionAsync.restoreAndReplaceAsync(byte[] payload)	Restores libraries using their state returned by RFunctionAsync.dumpAsync() method.
RFuture<Void>	RObjectAsync.restoreAndReplaceAsync(byte[] state)	Restores and replaces object if it already exists.
RFuture<Void>	RObjectAsync.restoreAndReplaceAsync(byte[] state, long timeToLive, TimeUnit timeUnit)	Restores and replaces object if it already exists and set time to live for it.
RFuture<Void>	RFunctionAsync.restoreAsync(byte[] payload)	Restores libraries using their state returned by RFunctionAsync.dumpAsync() method.
RFuture<Void>	RObjectAsync.restoreAsync(byte[] state)	Restores object using its state returned by RObjectAsync.dumpAsync() method.
RFuture<Void>	RObjectAsync.restoreAsync(byte[] state, long timeToLive, TimeUnit timeUnit)	Restores object using its state returned by RObjectAsync.dumpAsync() method and set time to live for it.
RFuture<Boolean>	RCollectionAsync.retainAllAsync(Collection<?> c)	Retains only the elements in this collection that are contained in the specified collection.
RFuture<Boolean>	RScoredSortedSetAsync.retainAllAsync(Collection<?> c)	Retains only the elements in this sorted set that are contained in the specified collection.
RFuture<Integer>	RScoredSortedSetAsync.revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
RFuture<Integer>	RScoredSortedSetAsync.revRangeToAsync(String destName, double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Stores to defined ScoredSortedSet values in reversed order between startScore and endScore.
RFuture<Integer>	RScoredSortedSetAsync.revRangeToAsync(String destName, int startIndex, int endIndex)	Stores to defined ScoredSortedSet values in reversed order by rank range.
RFuture<Integer>	RLexSortedSetAsync.revRankAsync(String o)	Returns rank of value, with the scores ordered from high to low.
RFuture<List<Integer>>	RScoredSortedSetAsync.revRankAsync(Collection<V> elements)	Returns ranks of elements, with the scores ordered from high to low.
RFuture<Integer>	RScoredSortedSetAsync.revRankAsync(V o)	Returns rank of value, with the scores ordered from high to low.
RFuture<Void>	RTransaction.rollbackAsync()	Rollback all changes made on this transaction in async mode.
RFuture<List<Boolean>>	RScriptAsync.scriptExistsAsync(String... shaDigests)	Checks for presence Lua scripts in Redis script cache by SHA-1 digest.
RFuture<List<Boolean>>	RScriptAsync.scriptExistsAsync(String key, String... shaDigests)	Checks for presence Lua scripts in Redis script cache by SHA-1 digest.
RFuture<Void>	RScriptAsync.scriptFlushAsync()	Flushes Lua script cache.
RFuture<Void>	RScriptAsync.scriptKillAsync()	Kills currently executed Lua script
RFuture<String>	RScriptAsync.scriptLoadAsync(String luaScript)	Loads Lua script into Redis scripts cache and returns its SHA-1 digest
RFuture<String>	RScriptAsync.scriptLoadAsync(String key, String luaScript)	Loads Lua script into Redis scripts cache and returns its SHA-1 digest
RFuture<List<V>>	RGeoAsync.searchAsync(GeoSearchArgs args)	Returns the members of a sorted set, which are within the borders of specified search conditions.
RFuture<Map<V,Double>>	RGeoAsync.searchWithDistanceAsync(GeoSearchArgs args)	Returns the distance mapped by member of a sorted set, which are within the borders of specified search conditions.
RFuture<Map<V,GeoPosition>>	RGeoAsync.searchWithPositionAsync(GeoSearchArgs args)	Returns the position mapped by member of a sorted set, which are within the borders of specified search conditions.
RFuture<Void>	RBucketAsync.setAndKeepTTLAsync(V value)	Set value and keep existing TTL.
RFuture<Void>	RAtomicDoubleAsync.setAsync(double newValue)	Atomically sets the given value.
RFuture<Void>	RAtomicLongAsync.setAsync(long newValue)	Atomically sets the given value.
RFuture<Boolean>	RBitSetAsync.setAsync(long bitIndex)	Set bit to one at specified bitIndex
RFuture<Boolean>	RBitSetAsync.setAsync(long bitIndex, boolean value)	Set bit to value at specified bitIndex
RFuture<Void>	RBitSetAsync.setAsync(long fromIndex, long toIndex)	Set all bits to one from fromIndex (inclusive) to toIndex (exclusive)
RFuture<Void>	RBitSetAsync.setAsync(long fromIndex, long toIndex, boolean value)	Set all bits to value from fromIndex (inclusive) to toIndex (exclusive)
RFuture<Void>	RBitSetAsync.setAsync(BitSet bs)	Copy bits state of source BitSet object to this object
RFuture<Void>	RBucketAsync.setAsync(V value)	Stores element into the holder.
RFuture<Void>	RBucketAsync.setAsync(V value, long timeToLive, TimeUnit timeUnit)	Stores element into the holder with defined timeToLive interval.
RFuture<Void>	RBucketsAsync.setAsync(Map<String,?> buckets)	Saves objects mapped by Redis key.
RFuture<Void>	RJsonBucketAsync.setAsync(String path, Object value)	Stores object into element by specified JSONPath.
RFuture<V>	RListAsync.setAsync(int index, V element)	Set element at index and returns previous element.
RFuture<Byte>	RBitSetAsync.setByteAsync(long offset, byte value)	Returns previous value of byte number and replaces it with defined value at specified offset
RFuture<Void>	RRingBufferAsync.setCapacityAsync(int capacity)	Sets capacity of the queue and overrides current value.
RFuture<Boolean>	RBucketAsync.setIfAbsentAsync(V value)	Sets value only if object holder doesn't exist.
RFuture<Boolean>	RBucketAsync.setIfAbsentAsync(V value, Duration duration)	Sets value with defined duration only if object holder doesn't exist.
RFuture<Boolean>	RJsonBucketAsync.setIfAbsentAsync(String path, Object value)	Sets Json object by JSONPath only if previous value is empty
RFuture<Boolean>	RBucketAsync.setIfExistsAsync(V value)	Sets value only if it's already exists.
RFuture<Boolean>	RBucketAsync.setIfExistsAsync(V value, long timeToLive, TimeUnit timeUnit)	Sets value only if it's already exists.
RFuture<Boolean>	RJsonBucketAsync.setIfExistsAsync(String path, Object value)	Sets Json object by JSONPath only if previous value is non-empty
RFuture<Integer>	RBitSetAsync.setIntegerAsync(long offset, int value)	Returns previous value of integer number and replaces it with defined value at specified offset
RFuture<Long>	RBitSetAsync.setLongAsync(long offset, long value)	Returns previous value of long number and replaces it with defined value at specified offset
RFuture<Void>	RMapCacheAsync.setMaxSizeAsync(int maxSize)	Sets max size of the map and overrides current value.
RFuture<Void>	RMapCacheAsync.setMaxSizeAsync(int maxSize, EvictionMode mode)	Sets max size of the map and overrides current value.
RFuture<Void>	RRateLimiterAsync.setRateAsync(RateType mode, long rate, long rateInterval, RateIntervalUnit rateIntervalUnit)	Updates RateLimiter's state and stores config to Redis server.
RFuture<Short>	RBitSetAsync.setShortAsync(long offset, short value)	Returns previous value of short number and replaces it with defined value at specified offset
RFuture<Long>	RBitSetAsync.setSignedAsync(int size, long offset, long value)	Returns previous value of signed number and replaces it with defined value at specified offset
RFuture<Long>	RBitSetAsync.setUnsignedAsync(int size, long offset, long value)	Returns previous value of unsigned number and replaces it with defined value at specified offset
RFuture<Long>	RBitSetAsync.sizeAsync()	Returns number of set bits.
RFuture<Long>	RBucketAsync.sizeAsync()	Returns size of object in bytes
RFuture<Integer>	RCollectionAsync.sizeAsync()	Returns number of elements in this collection.
RFuture<Integer>	RMapAsync.sizeAsync()	Returns size of this map
RFuture<Integer>	RMapCacheAsync.sizeAsync()	Returns the number of entries in cache.
RFuture<Integer>	RMultimapAsync.sizeAsync()	Returns the number of key-value pairs in this multimap.
RFuture<Long>	RReliableTopicAsync.sizeAsync()	Amount of messages stored in Redis Stream object.
RFuture<Integer>	RScoredSortedSetAsync.sizeAsync()	Returns size of this set.
RFuture<Integer>	RSetCacheAsync.sizeAsync()	Returns the number of elements in cache.
RFuture<Long>	RStreamAsync.sizeAsync()	Returns number of entries in stream
RFuture<Integer>	RTimeSeriesAsync.sizeAsync()	Returns size of this set.
RFuture<Long>	RObjectAsync.sizeInMemoryAsync()	Returns bytes amount used by object in Redis memory.
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order)	Sort data and store to destName list
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)	Sort data and store to destName list
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, String byPattern, SortOrder order)	Sort data and store to destName list
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count)	Sort data and store to destName list
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, SortOrder order)	Sort data and store to destName list
RFuture<Integer>	RSortableAsync.sortToAsync(String destName, SortOrder order, int offset, int count)	Sort data and store to destName list
RFuture<FunctionStats>	RFunctionAsync.statsAsync()	Returns information about currently running Redis function and available execution engines.
RFuture<Long>	RGeoAsync.storeSearchToAsync(String destName, GeoSearchArgs args)	Finds the members of a sorted set, which are within the borders of specified search conditions.
RFuture<Long>	RGeoReactive.storeSortedSearchTo(String destName, GeoSearchArgs args)	Finds the members of a sorted set, which are within the borders of specified search conditions.
RFuture<Long>	RGeoRx.storeSortedSearchTo(String destName, GeoSearchArgs args)	Finds the members of a sorted set, which are within the borders of specified search conditions.
RFuture<Long>	RGeoAsync.storeSortedSearchToAsync(String destName, GeoSearchArgs args)	Finds the members of a sorted set, which are within the borders of specified search conditions.
RFuture<Long>	RJsonBucketAsync.stringAppendAsync(String path, Object value)	Appends string data to element specified by JSONPath.
RFuture<List<Long>>	RJsonBucketAsync.stringAppendMultiAsync(String path, Object value)	Appends string data to elements specified by JSONPath.
RFuture<Long>	RJsonBucketAsync.stringSizeAsync(String path)	Returns size of string data by JSONPath
RFuture<List<Long>>	RJsonBucketAsync.stringSizeMultiAsync(String path)	Returns list of string data size by JSONPath.
RFuture<Double>	RDoubleAdder.sumAsync()	Accumulates sum across all RDoubleAdder instances
RFuture<Double>	RDoubleAdder.sumAsync(long timeout, TimeUnit timeUnit)	Accumulates sum across all RDoubleAdder instances within defined timeout.
RFuture<Long>	RLongAdder.sumAsync()	Accumulates sum across all RLongAdder instances
RFuture<Long>	RLongAdder.sumAsync(long timeout, TimeUnit timeUnit)	Accumulates sum across all RLongAdder instances within defined timeout.
RFuture<Void>	RKeysAsync.swapdbAsync(int db1, int db2)	Swap two databases.
RFuture<V>	RFuture.sync()	Deprecated.
RFuture<V>	RFuture.syncUninterruptibly()	Deprecated.
RFuture<V>	RBlockingQueueAsync.takeAsync()	Retrieves and removes the head of this queue in async mode, waiting if necessary until an element becomes available.
RFuture<V>	RBlockingDequeAsync.takeFirstAsync()	Retrieves and removes value at the head of queue.
RFuture<V>	RScoredSortedSetAsync.takeFirstAsync()	Removes and returns the head element waiting if necessary for an element to become available.
RFuture<V>	RBlockingQueueAsync.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.
RFuture<V>	RBlockingDequeAsync.takeLastAsync()	Retrieves and removes value at the tail of queue.
RFuture<V>	RScoredSortedSetAsync.takeLastAsync()	Removes and returns the tail element waiting if necessary for an element to become available.
RFuture<Time>	NodeAsync.timeAsync()	Deprecated.
RFuture<byte[]>	RBitSetAsync.toByteArrayAsync()
RFuture<Boolean>	RJsonBucketAsync.toggleAsync(String path)	Toggle boolean value specified by JSONPath
RFuture<List<Boolean>>	RJsonBucketAsync.toggleMultiAsync(String path)	Toggle boolean values specified by JSONPath
RFuture<Long>	RKeysAsync.touchAsync(String... names)	Update the last access time of an object.
RFuture<Boolean>	RObjectAsync.touchAsync()	Update the last access time of an object in async mode.
RFuture<Void>	RTransferQueueAsync.transferAsync(V e)	Transfers the element to waiting consumer which invoked RBlockingQueueAsync.takeAsync() or RBlockingQueueAsync.pollAsync(long, java.util.concurrent.TimeUnit) method at the moment of transfer.
RFuture<Void>	RListAsync.trimAsync(int fromIndex, int toIndex)	Trim list and remains elements only in specified range fromIndex, inclusive, and toIndex, inclusive.
RFuture<Long>	RStreamAsync.trimAsync(int size)	Deprecated.
RFuture<Long>	RStreamAsync.trimAsync(StreamTrimArgs args)
RFuture<Long>	RStreamAsync.trimAsync(TrimStrategy strategy, int threshold)	Deprecated.
RFuture<Long>	RStreamAsync.trimNonStrictAsync(int size)	Deprecated.
RFuture<Long>	RStreamAsync.trimNonStrictAsync(StreamTrimArgs args)
RFuture<Long>	RStreamAsync.trimNonStrictAsync(TrimStrategy strategy, int threshold)	Deprecated.
RFuture<Long>	RStreamAsync.trimNonStrictAsync(TrimStrategy strategy, int threshold, int limit)	Deprecated.
RFuture<String>	RPermitExpirableSemaphoreAsync.tryAcquireAsync()	Tries to acquire currently available permit and return its id.
RFuture<String>	RPermitExpirableSemaphoreAsync.tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit)	Tries to acquire currently available permit with defined leaseTime and return its id.
RFuture<String>	RPermitExpirableSemaphoreAsync.tryAcquireAsync(long waitTime, TimeUnit unit)	Tries to acquire currently available permit and return its id.
RFuture<Boolean>	RRateLimiterAsync.tryAcquireAsync()	Acquires a permit only if one is available at the time of invocation.
RFuture<Boolean>	RRateLimiterAsync.tryAcquireAsync(long permits)	Acquires the given number of permits only if all are available at the time of invocation.
RFuture<Boolean>	RRateLimiterAsync.tryAcquireAsync(long permits, long timeout, TimeUnit unit)	Acquires the given number of permits only if all are available within the given waiting time.
RFuture<Boolean>	RRateLimiterAsync.tryAcquireAsync(long timeout, TimeUnit unit)	Acquires a permit from this RateLimiter, if one becomes available within the given waiting time.
RFuture<Boolean>	RSemaphoreAsync.tryAcquireAsync()	Acquires a permit.
RFuture<Boolean>	RSemaphoreAsync.tryAcquireAsync(int permits)	Tries to acquire defined amount of currently available permits.
RFuture<Boolean>	RSemaphoreAsync.tryAcquireAsync(int permits, long waitTime, TimeUnit unit)	Tries to acquire defined amount of currently available permits.
RFuture<Boolean>	RSemaphoreAsync.tryAcquireAsync(long waitTime, TimeUnit unit)	Tries to acquire currently available permit.
RFuture<Boolean>	RGeoAsync.tryAddAsync(double longitude, double latitude, V member)	Adds geospatial member only if has not been added before.
RFuture<Long>	RGeoAsync.tryAddAsync(GeoEntry... entries)	Adds geospatial members only if has not been added before.
RFuture<Boolean>	RScoredSortedSetAsync.tryAddAsync(double score, V object)	Deprecated.
RFuture<Boolean>	RSetAsync.tryAddAsync(V... values)	Tries to add elements only if none of them in set.
RFuture<Boolean>	RSetCacheAsync.tryAddAsync(long ttl, TimeUnit unit, V... values)	Tries to add elements only if none of them in set.
RFuture<Boolean>	RSetCacheAsync.tryAddAsync(V... values)	Tries to add elements only if none of them in set.
<T> RFuture<Boolean>	RRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object)	Tries to execute one awaiting remote request.
<T> RFuture<Boolean>	RRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object, long timeout, TimeUnit timeUnit)	Tries to execute one awaiting remote request.
<T> RFuture<Boolean>	RRemoteService.tryExecuteAsync(Class<T> remoteInterface, T object, ExecutorService executorService, long timeout, TimeUnit timeUnit)	Tries to execute one awaiting remote request.
RFuture<Boolean>	RIdGeneratorAsync.tryInitAsync(long value, long allocationSize)	Initializes Id generator params.
RFuture<Boolean>	RLockAsync.tryLockAsync()	Tries to acquire the lock.
RFuture<Boolean>	RLockAsync.tryLockAsync(long threadId)	Tries to acquire the lock by thread with specified threadId.
RFuture<Boolean>	RLockAsync.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit)	Tries to acquire the lock with defined leaseTime.
RFuture<Boolean>	RLockAsync.tryLockAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId)	Tries to acquire the lock by thread with specified threadId and leaseTime.
RFuture<Boolean>	RLockAsync.tryLockAsync(long waitTime, TimeUnit unit)	Tries to acquire the lock.
RFuture<Boolean>	RPermitExpirableSemaphoreAsync.tryReleaseAsync(String permitId)	Tries to release permit by its id.
RFuture<Boolean>	RBucketAsync.trySetAsync(V value)	Deprecated.
RFuture<Boolean>	RBucketAsync.trySetAsync(V value, long timeToLive, TimeUnit timeUnit)	Deprecated.
RFuture<Boolean>	RBucketsAsync.trySetAsync(Map<String,?> buckets)	Try to save objects mapped by Redis key.
RFuture<Boolean>	RJsonBucketAsync.trySetAsync(String path, Object value)	Deprecated.
RFuture<Boolean>	RBoundedBlockingQueueAsync.trySetCapacityAsync(int capacity)	Sets queue capacity only if it is not set before.
RFuture<Boolean>	RRingBufferAsync.trySetCapacityAsync(int capacity)	Sets capacity of the queue only if it wasn't set before.
RFuture<Boolean>	RCountDownLatchAsync.trySetCountAsync(long count)	Sets new count value only if previous count already has reached zero or is not set at all.
RFuture<Boolean>	RMapCacheAsync.trySetMaxSizeAsync(int maxSize)	Tries to set max size of the map.
RFuture<Boolean>	RMapCacheAsync.trySetMaxSizeAsync(int maxSize, EvictionMode mode)	Tries to set max size of the map.
RFuture<Boolean>	RPermitExpirableSemaphoreAsync.trySetPermitsAsync(int permits)	Tries to set number of permits.
RFuture<Boolean>	RSemaphoreAsync.trySetPermitsAsync(int permits)	Tries to set number of permits.
RFuture<Boolean>	RRateLimiterAsync.trySetRateAsync(RateType mode, long rate, long rateInterval, RateIntervalUnit rateIntervalUnit)	Initializes RateLimiter's state and stores config to Redis server.
RFuture<Boolean>	RTransferQueueAsync.tryTransferAsync(V e)	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>	RTransferQueueAsync.tryTransferAsync(V e, 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.
RFuture<Integer>	RScoredSortedSetAsync.unionAsync(String... names)	Union provided ScoredSortedSets and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.unionAsync(Map<String,Double> nameWithWeight)	Union provided ScoredSortedSets mapped to weight multiplier and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.unionAsync(RScoredSortedSet.Aggregate aggregate, String... names)	Union provided ScoredSortedSets with defined aggregation method and store result to current ScoredSortedSet
RFuture<Integer>	RScoredSortedSetAsync.unionAsync(RScoredSortedSet.Aggregate aggregate, Map<String,Double> nameWithWeight)	Union provided ScoredSortedSets mapped to weight multiplier with defined aggregation method and store result to current ScoredSortedSet
RFuture<Integer>	RSetAsync.unionAsync(String... names)	Union sets specified by name and write to current set.
RFuture<Long>	RKeysAsync.unlinkAsync(String... keys)	Delete multiple objects by name.
RFuture<Boolean>	RObjectAsync.unlinkAsync()	Delete the objects.
RFuture<Void>	RLockAsync.unlockAsync()	Unlocks the lock
RFuture<Void>	RLockAsync.unlockAsync(long threadId)	Unlocks the lock.
RFuture<Boolean>	RMapCacheAsync.updateEntryExpirationAsync(K key, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	Updates time to live and max idle time of specified entry by key.
RFuture<Void>	RStreamAsync.updateGroupMessageIdAsync(String groupName, StreamMessageId id)	Updates next message id delivered to consumers.
RFuture<Boolean>	RPermitExpirableSemaphoreAsync.updateLeaseTimeAsync(String permitId, long leaseTime, TimeUnit unit)	Overrides and updates lease time for defined permit id.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Returns all values between startScore and endScore.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Returns all values between startScore and endScore.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeAsync(int startIndex, int endIndex)	Returns values by rank range.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive)	Returns all values between startScore and endScore in reversed order.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count)	Returns all values between startScore and endScore in reversed order.
RFuture<Collection<V>>	RScoredSortedSetAsync.valueRangeReversedAsync(int startIndex, int endIndex)	Returns values by rank range in reverse order.
RFuture<Integer>	RMapAsync.valueSizeAsync(K key)	Returns size of value mapped by key in bytes
RFuture<Void>	RBitSetAsync.xorAsync(String... bitSetNames)	Executes XOR operation over this object and specified bitsets.

Uses of RFuture in org.redisson.api.mapreduce

Methods in org.redisson.api.mapreduce that return RFuture

Modifier and Type	Method	Description
RFuture<Map<KOut,VOut>>	RMapReduceExecutor.executeAsync()	Executes MapReduce process across Redisson Nodes in asynchronous mode
RFuture<Void>	RMapReduceExecutor.executeAsync(String resultMapName)	Executes MapReduce process across Redisson Nodes in asynchronous mode and stores result in map with resultMapName
<R> RFuture<R>	RMapReduceExecutor.executeAsync(RCollator<KOut,VOut,R> collator)	Executes MapReduce process across Redisson Nodes in asynchronous mode and collides result using defined collator

Uses of RFuture in org.redisson.api.redisnode

Methods in org.redisson.api.redisnode that return RFuture

Modifier and Type	Method	Description
RFuture<Void>	RedisClusterNodeAsync.clusterAddSlotsAsync(int... slots)	Adds slots to this Redis node
RFuture<Long>	RedisClusterNodeAsync.clusterCountFailureReportsAsync(String nodeId)	Returns number of failure reports for Redis node by defined id
RFuture<Long>	RedisClusterNodeAsync.clusterCountKeysInSlotAsync(int slot)	Counts keys in defined slot
RFuture<Void>	RedisClusterNodeAsync.clusterDeleteSlotsAsync(int... slots)	Removes slots from this Redis node
RFuture<Void>	RedisClusterNodeAsync.clusterFlushSlotsAsync()	Removes all slots from this Redis node
RFuture<Void>	RedisClusterNodeAsync.clusterForgetAsync(String nodeId)	Removes Redis node by defined id from Cluster
RFuture<List<String>>	RedisClusterNodeAsync.clusterGetKeysInSlotAsync(int slot, int count)	Returns keys in defines slot limited by count
RFuture<String>	RedisClusterNodeAsync.clusterIdAsync()	Returns id of this Redis node
RFuture<Map<String,String>>	RedisClusterNodeAsync.clusterInfoAsync()	Returns cluster information reported by this Redis node
RFuture<Void>	RedisClusterNodeAsync.clusterMeetAsync(String address)	Joins Redis node by the defined address to Cluster
RFuture<Void>	RedisClusterNodeAsync.clusterReplicateAsync(String nodeId)	Reconfigures this Redis node as replica of Redis node by defined id.
RFuture<Void>	RedisClusterNodeAsync.clusterSetSlotAsync(int slot, SetSlotCommand command)	Sets slot to this Redis node according to defined command
RFuture<Void>	RedisClusterNodeAsync.clusterSetSlotAsync(int slot, SetSlotCommand command, String nodeId)	Sets slot to this Redis node according to defined command
RFuture<Map<ClusterSlotRange,Set<String>>>	RedisClusterNodeAsync.clusterSlotsAsync()	Return Redis Cluster slots mapped to Redis nodes
RFuture<Void>	RedisSentinelAsync.failoverAsync(String masterName)	Starts failover process for defined Redis master
RFuture<Map<String,String>>	RedisNodeAsync.getConfigAsync(String parameter)	Get value of Redis configuration parameter.
RFuture<RedisURI>	RedisSentinelAsync.getMasterAddrAsync(String masterName)	Returns network address of defined Redis master.
RFuture<Map<String,String>>	RedisSentinelAsync.getMasterAsync(String masterName)	Returns map containing info regarding defined Redis master.
RFuture<List<Map<String,String>>>	RedisSentinelAsync.getMastersAsync()	Returns list of map containing info regarding Redis Master server monitored by current Redis Sentinel server.
RFuture<Map<String,String>>	RedisNodeAsync.getMemoryStatisticsAsync()	Returns Redis memory statistics
RFuture<List<Map<String,String>>>	RedisSentinelAsync.getSentinelsAsync(String masterName)	Returns list of map containing info regarding Redis Sentinel server monitoring defined master.
RFuture<List<Map<String,String>>>	RedisSentinelAsync.getSlavesAsync(String masterName)	Returns list of map containing info regarding Redis Slave server of defined master.
RFuture<Map<String,String>>	RedisNodeAsync.infoAsync(RedisNode.InfoSection section)	Returns information about Redis node.
RFuture<Boolean>	RedisNodeAsync.pingAsync()	Ping Redis node.
RFuture<Boolean>	RedisNodeAsync.pingAsync(long timeout, TimeUnit timeUnit)	Ping Redis node with specified timeout.
RFuture<Void>	RedisNodeAsync.setConfigAsync(String parameter, String value)	Set value of Redis configuration parameter.
RFuture<Time>	RedisNodeAsync.timeAsync()	Returns current Redis server time in seconds

Uses of RFuture in org.redisson.cache

Methods in org.redisson.cache that return RFuture

Modifier and Type	Method	Description
RFuture<Void>	LocalCacheListener.clearLocalCacheAsync()

Uses of RFuture in org.redisson.client

Methods in org.redisson.client that return RFuture

Modifier and Type	Method	Description
<T, R> RFuture<R>	RedisConnection.async(long timeout, Codec encoder, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	RedisConnection.async(long timeout, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	RedisConnection.async(Codec encoder, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	RedisConnection.async(RedisCommand<T> command, Object... params)
RFuture<RedisConnection>	RedisClient.connectAsync()
RFuture<RedisPubSubConnection>	RedisClient.connectPubSubAsync()
RFuture<Void>	RedisClient.shutdownAsync()

Uses of RFuture in org.redisson.client.handler

Methods in org.redisson.client.handler with parameters of type RFuture

Modifier and Type	Method	Description
protected Throwable	PingConnectionHandler.cause(RFuture<?> future)

Uses of RFuture in org.redisson.command

Methods in org.redisson.command that return RFuture

Modifier and Type	Method	Description
<V, R> RFuture<R>	CommandAsyncExecutor.async(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry)
<V, R> RFuture<R>	CommandAsyncService.async(boolean readOnlyMode, NodeSource source, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry)
<V, R> RFuture<R>	CommandBatchService.async(boolean readOnlyMode, NodeSource nodeSource, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry)
RFuture<Void>	CommandBatchService.discardAsync()
<T, R> RFuture<R>	CommandAsyncExecutor.evalReadAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.evalReadAsync(RedisClient client, String name, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.evalReadAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalReadAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalReadAsync(RedisClient client, String name, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalReadAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.evalWriteAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalWriteAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.evalWriteNoRetryAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
<T, R> RFuture<R>	CommandAsyncService.evalWriteNoRetryAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params)
RFuture<BatchResult<?>>	CommandBatchService.executeAsync()
RFuture<Void>	CommandBatchService.executeAsyncVoid()
<V> RFuture<V>	CommandAsyncExecutor.pollFromAnyAsync(String name, Codec codec, RedisCommand<?> command, long secondsTimeout, String... queueNames)
<V> RFuture<V>	CommandAsyncService.pollFromAnyAsync(String name, Codec codec, RedisCommand<?> command, long secondsTimeout, String... queueNames)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(String key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(String key, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(RedisClient client, byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(RedisClient client, String name, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(RedisClient client, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(RedisClient client, MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(String key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(String key, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(RedisClient client, byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(RedisClient client, String name, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(RedisClient client, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(RedisClient client, MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readBatchedAsync(Codec codec, RedisCommand<T> command, SlotCallback<T,R> callback, String... keys)
<T, R> RFuture<R>	CommandAsyncService.readBatchedAsync(Codec codec, RedisCommand<T> command, SlotCallback<T,R> callback, String... keys)
<T, R> RFuture<R>	CommandAsyncExecutor.readRandomAsync(Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.readRandomAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readRandomAsync(Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.readRandomAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T> RFuture<Void>	CommandAsyncExecutor.writeAllVoidAsync(RedisCommand<T> command, Object... params)
<T> RFuture<Void>	CommandAsyncService.writeAllVoidAsync(RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeAsync(byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeAsync(String key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeAsync(String key, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeAsync(RedisClient client, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.writeAsync(byte[] key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.writeAsync(String key, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.writeAsync(String key, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.writeAsync(RedisClient client, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncService.writeAsync(MasterSlaveEntry entry, Codec codec, RedisCommand<T> command, Object... params)
<T, R> RFuture<R>	CommandAsyncExecutor.writeBatchedAsync(Codec codec, RedisCommand<T> command, SlotCallback<T,R> callback, String... keys)
<T, R> RFuture<R>	CommandAsyncService.writeBatchedAsync(Codec codec, RedisCommand<T> command, SlotCallback<T,R> callback, String... keys)

Methods in org.redisson.command with parameters of type RFuture

Modifier and Type	Method	Description
void	CommandBatchService.add(RFuture<?> future, List<CommandBatchService> services)
<V> V	CommandAsyncExecutor.get(RFuture<V> future)
<V> V	CommandAsyncService.get(RFuture<V> future)
<V> V	CommandSyncExecutor.get(RFuture<V> future)
<V> V	CommandAsyncExecutor.getInterrupted(RFuture<V> future)
<V> V	CommandAsyncService.getInterrupted(RFuture<V> future)
protected void	CommandBatchService.handle(CompletableFuture<Void> mainPromise, AtomicInteger slots, RFuture<?> future)

Uses of RFuture in org.redisson.connection

Methods in org.redisson.connection that return RFuture

Modifier and Type	Method	Description
RFuture<Map<String,String>>	RedisClientEntry.clusterInfoAsync()
RFuture<Map<String,String>>	RedisClientEntry.infoAsync(Node.InfoSection section)
RFuture<Boolean>	RedisClientEntry.pingAsync()
RFuture<Boolean>	RedisClientEntry.pingAsync(long timeout, TimeUnit timeUnit)
RFuture<Time>	RedisClientEntry.timeAsync()

Uses of RFuture in org.redisson.executor

Classes in org.redisson.executor that implement RFuture

Modifier and Type	Class	Description
class	RedissonExecutorBatchFuture
class	RedissonExecutorFuture<V>
class	RedissonScheduledFuture<V>

Fields in org.redisson.executor with type parameters of type RFuture

Modifier and Type	Field	Description
protected final BlockingQueue<RFuture<V>>	RedissonCompletionService.completionQueue

Methods in org.redisson.executor that return RFuture

Modifier and Type	Method	Description
RFuture<Boolean>	TasksService.cancelExecutionAsync(String requestId)
RFuture<List<Boolean>>	TasksBatchService.executeAddAsync()
<T> RFuture<T>	RemoteExecutorServiceAsync.executeCallable(TaskParameters params)
RFuture<Void>	RemoteExecutorServiceAsync.executeRunnable(TaskParameters params)
protected RFuture<RemoteServiceRequest>	RedissonExecutorRemoteService.getTask(String requestId, RMap<String,RemoteServiceRequest> tasks)
RFuture<Boolean>	TasksService.hasTaskAsync(String taskId)
protected RFuture<Long>	TasksRunnerService.renewRetryTime(String requestId)
RFuture<Void>	RemoteExecutorServiceAsync.schedule(ScheduledCronExpressionParameters params)
RFuture<Void>	RemoteExecutorServiceAsync.scheduleAtFixedRate(ScheduledAtFixedRateParameters params)
<T> RFuture<T>	RemoteExecutorServiceAsync.scheduleCallable(ScheduledParameters params)
RFuture<Void>	RemoteExecutorServiceAsync.scheduleRunnable(ScheduledParameters params)
RFuture<Void>	RemoteExecutorServiceAsync.scheduleWithFixedDelay(ScheduledWithFixedDelayParameters params)

Constructor parameters in org.redisson.executor with type arguments of type RFuture

Modifier	Constructor	Description
	RedissonCompletionService(RScheduledExecutorService executorService, BlockingQueue<RFuture<V>> completionQueue)

Uses of RFuture in org.redisson.jcache

Methods in org.redisson.jcache that return RFuture

Modifier and Type	Method	Description
RFuture<Void>	JCache.clearAsync()
RFuture<Boolean>	JCache.containsKeyAsync(K key)
RFuture<Map<K,V>>	JCache.getAllAsync(Set<? extends K> keys)
RFuture<V>	JCache.getAndPutAsync(K key, V value)
RFuture<V>	JCache.getAndRemoveAsync(K key)
RFuture<V>	JCache.getAndReplaceAsync(K key, V value)
RFuture<V>	JCache.getAsync(K key)
RFuture<Void>	JCache.putAllAsync(Map<? extends K,? extends V> map)
RFuture<Void>	JCache.putAsync(K key, V value)
RFuture<Boolean>	JCache.putIfAbsentAsync(K key, V value)
RFuture<Void>	JCache.removeAllAsync(Set<? extends K> keys)
RFuture<Boolean>	JCache.removeAsync(K key)
RFuture<Boolean>	JCache.removeAsync(K key, V value)
RFuture<Boolean>	JCache.replaceAsync(K key, V value)
RFuture<Boolean>	JCache.replaceAsync(K key, V oldValue, V newValue)

Uses of RFuture in org.redisson.misc

Classes in org.redisson.misc that implement RFuture

Modifier and Type	Class	Description
class	CompletableFutureWrapper<V>

Methods in org.redisson.misc that return RFuture

Modifier and Type	Method	Description
RFuture<V>	CompletableFutureWrapper.await()
RFuture<V>	CompletableFutureWrapper.awaitUninterruptibly()
RFuture<V>	CompletableFutureWrapper.sync()
RFuture<V>	CompletableFutureWrapper.syncUninterruptibly()

Uses of RFuture in org.redisson.reactive

Methods in org.redisson.reactive that return RFuture

Modifier and Type	Method	Description
abstract RFuture<Boolean>	PublisherAdder.add(Object o)
<V, R> RFuture<R>	CommandReactiveBatchService.async(boolean readOnlyMode, NodeSource nodeSource, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry)
RFuture<Void>	CommandReactiveBatchService.discardAsync()
RFuture<BatchResult<?>>	CommandReactiveBatchService.executeAsync()
protected abstract RFuture<ScanResult<Object>>	IteratorConsumer.scanIterator(RedisClient client, long nextIterPos)
RFuture<ScanResult<Object>>	MapReactiveIterator.scanIterator(RedisClient client, long nextIterPos)
protected abstract RFuture<ScanResult<Object>>	SetReactiveIterator.scanIterator(RedisClient client, long nextIterPos)

Method parameters in org.redisson.reactive with type arguments of type RFuture

Modifier and Type	Method	Description
<R> reactor.core.publisher.Mono<R>	CommandReactiveBatchService.reactive(Callable<RFuture<R>> supplier)
<R> reactor.core.publisher.Mono<R>	CommandReactiveExecutor.reactive(Callable<RFuture<R>> supplier)
<R> reactor.core.publisher.Mono<R>	CommandReactiveService.reactive(Callable<RFuture<R>> supplier)
static <V> reactor.core.publisher.Flux<V>	ElementsStream.takeElements(Callable<RFuture<V>> callable)

Uses of RFuture in org.redisson.redisnode

Methods in org.redisson.redisnode that return RFuture

Modifier and Type	Method	Description
RFuture<Void>	RedisNode.clusterAddSlotsAsync(int... slots)
RFuture<Long>	RedisNode.clusterCountFailureReportsAsync(String nodeId)
RFuture<Long>	RedisNode.clusterCountKeysInSlotAsync(int slot)
RFuture<Void>	RedisNode.clusterDeleteSlotsAsync(int... slots)
RFuture<Void>	RedisNode.clusterFlushSlotsAsync()
RFuture<Void>	RedisNode.clusterForgetAsync(String nodeId)
RFuture<List<String>>	RedisNode.clusterGetKeysInSlotAsync(int slot, int count)
RFuture<String>	RedisNode.clusterIdAsync()
RFuture<Map<String,String>>	RedisNode.clusterInfoAsync()
RFuture<Void>	RedisNode.clusterMeetAsync(String address)
RFuture<Void>	RedisNode.clusterReplicateAsync(String nodeId)
RFuture<Void>	RedisNode.clusterSetSlotAsync(int slot, SetSlotCommand command)
RFuture<Void>	RedisNode.clusterSetSlotAsync(int slot, SetSlotCommand command, String nodeId)
RFuture<Map<ClusterSlotRange,Set<String>>>	RedisNode.clusterSlotsAsync()
RFuture<Void>	SentinelRedisNode.failoverAsync(String masterName)
RFuture<Map<String,String>>	RedisNode.getConfigAsync(String parameter)
RFuture<Map<String,String>>	SentinelRedisNode.getConfigAsync(String parameter)
RFuture<RedisURI>	SentinelRedisNode.getMasterAddrAsync(String masterName)
RFuture<Map<String,String>>	SentinelRedisNode.getMasterAsync(String masterName)
RFuture<List<Map<String,String>>>	SentinelRedisNode.getMastersAsync()
RFuture<Map<String,String>>	RedisNode.getMemoryStatisticsAsync()
RFuture<Map<String,String>>	SentinelRedisNode.getMemoryStatisticsAsync()
RFuture<List<Map<String,String>>>	SentinelRedisNode.getSentinelsAsync(String masterName)
RFuture<List<Map<String,String>>>	SentinelRedisNode.getSlavesAsync(String masterName)
RFuture<Map<String,String>>	RedisNode.infoAsync(RedisNode.InfoSection section)
RFuture<Map<String,String>>	SentinelRedisNode.infoAsync(RedisNode.InfoSection section)
RFuture<Boolean>	RedisNode.pingAsync()
RFuture<Boolean>	RedisNode.pingAsync(long timeout, TimeUnit timeUnit)
RFuture<Boolean>	SentinelRedisNode.pingAsync()
RFuture<Boolean>	SentinelRedisNode.pingAsync(long timeout, TimeUnit timeUnit)
RFuture<Void>	RedisNode.setConfigAsync(String parameter, String value)
RFuture<Void>	SentinelRedisNode.setConfigAsync(String parameter, String value)
RFuture<Time>	RedisNode.timeAsync()
RFuture<Time>	SentinelRedisNode.timeAsync()

Uses of RFuture in org.redisson.rx

Methods in org.redisson.rx that return RFuture

Modifier and Type	Method	Description
abstract RFuture<Boolean>	PublisherAdder.add(Object o)
<V, R> RFuture<R>	CommandRxBatchService.async(boolean readOnlyMode, NodeSource nodeSource, Codec codec, RedisCommand<V> command, Object[] params, boolean ignoreRedirect, boolean noRetry)
protected abstract RFuture<ScanResult<Object>>	SetRxIterator.scanIterator(RedisClient client, long nextIterPos)

Method parameters in org.redisson.rx with type arguments of type RFuture

Modifier and Type	Method	Description
static <V> io.reactivex.rxjava3.core.Flowable<V>	ElementsStream.takeElements(Supplier<RFuture<V>> callable)

Uses of RFuture in org.redisson.transaction

Methods in org.redisson.transaction that return RFuture

Modifier and Type	Method	Description
RFuture<Boolean>	BaseTransactionalSet.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonTransactionalSet.addAllAsync(Collection<? extends V> c)
RFuture<Boolean>	RedissonTransactionalSetCache.addAllAsync(Collection<? extends V> c)
protected RFuture<V>	BaseTransactionalMap.addAndGetOperationAsync(K key, Number value)
protected RFuture<V>	RedissonTransactionalMap.addAndGetOperationAsync(K key, Number value)
protected RFuture<V>	RedissonTransactionalMapCache.addAndGetOperationAsync(K key, Number value)
RFuture<Boolean>	BaseTransactionalSet.addAsync(V value)
RFuture<Boolean>	BaseTransactionalSet.addAsync(V value, TransactionalOperation operation)
RFuture<Boolean>	RedissonTransactionalSet.addAsync(V e)
RFuture<Boolean>	RedissonTransactionalSetCache.addAsync(V e)
RFuture<Boolean>	RedissonTransactionalSetCache.addAsync(V value, long ttl, TimeUnit unit)
RFuture<Boolean>	TransactionalSetCache.addAsync(V value, long ttl, TimeUnit ttlUnit)
RFuture<Boolean>	BaseTransactionalMap.clearExpireAsync()
RFuture<Boolean>	BaseTransactionalSet.clearExpireAsync()
RFuture<Boolean>	RedissonTransactionalBucket.clearExpireAsync()
RFuture<Boolean>	RedissonTransactionalMap.clearExpireAsync()
RFuture<Boolean>	RedissonTransactionalMapCache.clearExpireAsync()
RFuture<Boolean>	RedissonTransactionalSet.clearExpireAsync()
RFuture<Boolean>	RedissonTransactionalSetCache.clearExpireAsync()
RFuture<Void>	RedissonTransactionalLocalCachedMap.clearLocalCacheAsync()
RFuture<Void>	RedissonTransaction.commitAsync()
RFuture<Boolean>	RedissonTransactionalBucket.compareAndSetAsync(V expect, V update)
RFuture<Boolean>	BaseTransactionalSet.containsAllAsync(Collection<?> c)
RFuture<Boolean>	BaseTransactionalSet.containsAsync(Object value)
RFuture<Boolean>	RedissonTransactionalSet.containsAsync(Object o)
RFuture<Boolean>	RedissonTransactionalSetCache.containsAsync(Object o)
RFuture<Boolean>	BaseTransactionalMap.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonTransactionalMap.containsKeyAsync(Object key)
RFuture<Boolean>	RedissonTransactionalMapCache.containsKeyAsync(Object key)
RFuture<Boolean>	BaseTransactionalMap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonTransactionalMap.containsValueAsync(Object value)
RFuture<Boolean>	RedissonTransactionalMapCache.containsValueAsync(Object value)
RFuture<Boolean>	BaseTransactionalMap.deleteAsync(CommandAsyncExecutor commandExecutor)
protected RFuture<Boolean>	BaseTransactionalMap.deleteAsync(CommandAsyncExecutor commandExecutor, TransactionalOperation operation)
RFuture<Boolean>	BaseTransactionalSet.deleteAsync()
protected RFuture<Boolean>	BaseTransactionalSet.deleteAsync(TransactionalOperation operation)
RFuture<Boolean>	RedissonTransactionalBucket.deleteAsync()
RFuture<Boolean>	RedissonTransactionalMap.deleteAsync()
RFuture<Boolean>	RedissonTransactionalMapCache.deleteAsync()
RFuture<Boolean>	RedissonTransactionalSet.deleteAsync()
RFuture<Boolean>	RedissonTransactionalSetCache.deleteAsync()
RFuture<Integer>	BaseTransactionalSet.diffAsync(String... names)
RFuture<Integer>	RedissonTransactionalSet.diffAsync(String... names)
protected <R> RFuture<R>	BaseTransactionalMap.executeLocked(K key, Supplier<CompletionStage<R>> runnable)
protected <R> RFuture<R>	BaseTransactionalObject.executeLocked(long threadId, long timeout, Supplier<CompletionStage<R>> runnable, RLock lock)
protected <R> RFuture<R>	BaseTransactionalObject.executeLocked(long timeout, Supplier<CompletionStage<R>> runnable, List<RLock> locks)
protected <R> RFuture<R>	BaseTransactionalObject.executeLocked(long timeout, Supplier<CompletionStage<R>> runnable, RLock lock)
protected <R> RFuture<R>	BaseTransactionalSet.executeLocked(Object value, Supplier<CompletionStage<R>> runnable)
protected <R> RFuture<R>	BaseTransactionalSet.executeLocked(Supplier<CompletionStage<R>> runnable, Collection<?> values)
protected <R> RFuture<R>	RedissonTransactionalBucket.executeLocked(Supplier<CompletionStage<R>> runnable)
protected <R> RFuture<R>	RedissonTransactionalBuckets.executeLocked(Supplier<CompletionStage<R>> runnable, Collection<String> keys)
RFuture<Boolean>	BaseTransactionalMap.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	BaseTransactionalSet.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalBucket.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonTransactionalMap.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonTransactionalMapCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonTransactionalSet.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	RedissonTransactionalSetCache.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	BaseTransactionalMap.expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	BaseTransactionalSet.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalBucket.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalMap.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalMapCache.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalSet.expireAtAsync(long timestamp, String param, String... keys)
protected RFuture<Boolean>	RedissonTransactionalSetCache.expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	BaseTransactionalMapCache.fastPutIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<Boolean>	RedissonTransactionalMapCache.fastPutIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutIfAbsentOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<Boolean>	RedissonTransactionalMap.fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonTransactionalMapCache.fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutIfExistsOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<Boolean>	RedissonTransactionalMap.fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonTransactionalMapCache.fastPutIfExistsOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.fastPutOperationAsync(K key, V value, MapOperation operation)
RFuture<Boolean>	BaseTransactionalMapCache.fastPutOperationAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<Boolean>	RedissonTransactionalMap.fastPutOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonTransactionalMapCache.fastPutOperationAsync(K key, V value)
RFuture<Boolean>	RedissonTransactionalMapCache.fastPutOperationAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<Long>	BaseTransactionalMap.fastRemoveOperationAsync(K... keys)
protected RFuture<Long>	RedissonTransactionalMap.fastRemoveOperationAsync(K... keys)
protected RFuture<Long>	RedissonTransactionalMapCache.fastRemoveOperationAsync(K... keys)
protected RFuture<Map<K,V>>	BaseTransactionalMap.getAllOperationAsync(Set<K> keys)
RFuture<Map<K,V>>	RedissonTransactionalMap.getAllOperationAsync(Set<K> keys)
RFuture<Map<K,V>>	RedissonTransactionalMapCache.getAllOperationAsync(Set<K> keys)
RFuture<V>	RedissonTransactionalBucket.getAndDeleteAsync()
RFuture<V>	RedissonTransactionalBucket.getAndSetAsync(V value)
RFuture<V>	RedissonTransactionalBucket.getAndSetAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<V>	RedissonTransactionalBucket.getAsync()
<V> RFuture<Map<String,V>>	RedissonTransactionalBuckets.getAsync(String... keys)
protected RFuture<V>	BaseTransactionalMap.getOperationAsync(K key)
RFuture<V>	RedissonTransactionalMap.getOperationAsync(K key)
RFuture<V>	RedissonTransactionalMapCache.getOperationAsync(K key)
RFuture<Integer>	BaseTransactionalSet.intersectionAsync(String... names)
RFuture<Integer>	RedissonTransactionalSet.intersectionAsync(String... names)
RFuture<Boolean>	BaseTransactionalMap.isExistsAsync()
RFuture<Boolean>	BaseTransactionalSet.isExistsAsync()
RFuture<Boolean>	RedissonTransactionalBucket.isExistsAsync()
RFuture<Boolean>	RedissonTransactionalMap.isExistsAsync()
RFuture<Boolean>	RedissonTransactionalMapCache.isExistsAsync()
RFuture<Void>	RedissonTransactionalMap.loadAllAsync(boolean replaceExistingValues, int parallelism)
RFuture<Void>	RedissonTransactionalMap.loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RFuture<Void>	RedissonTransactionalMapCache.loadAllAsync(boolean replaceExistingValues, int parallelism)
RFuture<Void>	RedissonTransactionalMapCache.loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RFuture<Void>	BaseTransactionalObject.migrateAsync(String host, int port, int database)
RFuture<Void>	RedissonTransactionalBucket.migrateAsync(String host, int port, int database, long timeout)
RFuture<Void>	RedissonTransactionalMap.migrateAsync(String host, int port, int database, long timeout)
RFuture<Void>	RedissonTransactionalMapCache.migrateAsync(String host, int port, int database, long timeout)
RFuture<Void>	RedissonTransactionalSet.migrateAsync(String host, int port, int database, long timeout)
RFuture<Void>	RedissonTransactionalSetCache.migrateAsync(String host, int port, int database, long timeout)
RFuture<Boolean>	BaseTransactionalObject.moveAsync(int database)
RFuture<Boolean>	BaseTransactionalSet.moveAsync(String destination, V value)
RFuture<Boolean>	RedissonTransactionalBucket.moveAsync(int database)
RFuture<Boolean>	RedissonTransactionalMap.moveAsync(int database)
RFuture<Boolean>	RedissonTransactionalMapCache.moveAsync(int database)
RFuture<Boolean>	RedissonTransactionalSet.moveAsync(int database)
RFuture<Boolean>	RedissonTransactionalSet.moveAsync(String destination, V member)
RFuture<Boolean>	RedissonTransactionalSetCache.moveAsync(int database)
protected RFuture<Void>	BaseTransactionalMap.putAllOperationAsync(Map<? extends K,? extends V> entries)
protected RFuture<Void>	RedissonTransactionalMap.putAllOperationAsync(Map<? extends K,? extends V> entries)
protected RFuture<Void>	RedissonTransactionalMapCache.putAllOperationAsync(Map<? extends K,? extends V> entries)
RFuture<V>	BaseTransactionalMapCache.putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
RFuture<V>	RedissonTransactionalMapCache.putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)
protected RFuture<V>	BaseTransactionalMap.putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	BaseTransactionalMap.putIfAbsentOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<V>	RedissonTransactionalMap.putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	RedissonTransactionalMapCache.putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	BaseTransactionalMap.putIfExistsOperationAsync(K key, V value)
protected RFuture<V>	BaseTransactionalMap.putIfExistsOperationAsync(K key, V value, MapOperation mapOperation)
protected RFuture<V>	RedissonTransactionalMap.putIfExistsOperationAsync(K key, V value)
protected RFuture<V>	RedissonTransactionalMapCache.putIfExistsOperationAsync(K key, V value)
protected final RFuture<V>	BaseTransactionalMap.putOperationAsync(K key, V value)
protected RFuture<V>	BaseTransactionalMap.putOperationAsync(K key, V value, MapOperation operation)
RFuture<V>	BaseTransactionalMapCache.putOperationAsync(K key, V value, long ttlTimeout, long maxIdleTimeout, long maxIdleDelta, long ttlTimeoutDelta)
protected RFuture<V>	RedissonTransactionalMap.putOperationAsync(K key, V value)
protected RFuture<V>	RedissonTransactionalMapCache.putOperationAsync(K key, V value)
RFuture<V>	RedissonTransactionalMapCache.putOperationAsync(K key, V value, long ttlTimeout, long maxIdleTimeout, long maxIdleDelta, long ttlTimeoutDelta)
RFuture<Set<V>>	BaseTransactionalSet.readAllAsync()
RFuture<Set<V>>	RedissonTransactionalSet.readAllAsync()
RFuture<Set<V>>	RedissonTransactionalSetCache.readAllAsync()
protected abstract RFuture<Set<V>>	BaseTransactionalSet.readAllAsyncSource()
protected RFuture<Set<V>>	TransactionalSet.readAllAsyncSource()
protected RFuture<Set<V>>	TransactionalSetCache.readAllAsyncSource()
RFuture<Set<Map.Entry<K,V>>>	BaseTransactionalMap.readAllEntrySetAsync()
RFuture<Set<Map.Entry<K,V>>>	RedissonTransactionalMap.readAllEntrySetAsync()
RFuture<Set<Map.Entry<K,V>>>	RedissonTransactionalMapCache.readAllEntrySetAsync()
RFuture<Set<K>>	BaseTransactionalMap.readAllKeySetAsync()
RFuture<Set<K>>	RedissonTransactionalMap.readAllKeySetAsync()
RFuture<Set<K>>	RedissonTransactionalMapCache.readAllKeySetAsync()
RFuture<Map<K,V>>	BaseTransactionalMap.readAllMapAsync()
RFuture<Map<K,V>>	RedissonTransactionalMap.readAllMapAsync()
RFuture<Map<K,V>>	RedissonTransactionalMapCache.readAllMapAsync()
RFuture<Collection<V>>	BaseTransactionalMap.readAllValuesAsync()
RFuture<Collection<V>>	RedissonTransactionalMap.readAllValuesAsync()
RFuture<Collection<V>>	RedissonTransactionalMapCache.readAllValuesAsync()
RFuture<Set<V>>	BaseTransactionalSet.readDiffAsync(String... names)
RFuture<Set<V>>	RedissonTransactionalSet.readDiffAsync(String... names)
RFuture<Set<V>>	BaseTransactionalSet.readIntersectionAsync(String... names)
RFuture<Set<V>>	RedissonTransactionalSet.readIntersectionAsync(String... names)
<T> RFuture<Collection<T>>	BaseTransactionalSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	BaseTransactionalSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	BaseTransactionalSet.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	BaseTransactionalSet.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	BaseTransactionalSet.readSortAlphaAsync(SortOrder order)
RFuture<Set<V>>	BaseTransactionalSet.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonTransactionalSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order)
<T> RFuture<Collection<T>>	RedissonTransactionalSet.readSortAlphaAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAlphaAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAlphaAsync(String byPattern, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAlphaAsync(SortOrder order)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAlphaAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	BaseTransactionalSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	BaseTransactionalSet.readSortAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	BaseTransactionalSet.readSortAsync(SortOrder order)
RFuture<Set<V>>	BaseTransactionalSet.readSortAsync(SortOrder order, int offset, int count)
<T> RFuture<Collection<T>>	RedissonTransactionalSet.readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAsync(String byPattern, SortOrder order)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAsync(SortOrder order)
RFuture<Set<V>>	RedissonTransactionalSet.readSortAsync(SortOrder order, int offset, int count)
RFuture<Set<V>>	BaseTransactionalSet.readUnionAsync(String... names)
RFuture<Set<V>>	RedissonTransactionalSet.readUnionAsync(String... names)
RFuture<Long>	RedissonTransactionalMapCache.remainTimeToLiveAsync()
RFuture<Boolean>	BaseTransactionalSet.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransactionalSet.removeAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransactionalSetCache.removeAllAsync(Collection<?> c)
RFuture<Boolean>	BaseTransactionalSet.removeAsync(Object value)
RFuture<Boolean>	RedissonTransactionalSet.removeAsync(Object o)
RFuture<Boolean>	RedissonTransactionalSetCache.removeAsync(Object o)
protected RFuture<Boolean>	BaseTransactionalMap.removeOperationAsync(Object key, Object value)
protected RFuture<V>	BaseTransactionalMap.removeOperationAsync(K key)
protected RFuture<Boolean>	RedissonTransactionalMap.removeOperationAsync(Object key, Object value)
protected RFuture<V>	RedissonTransactionalMap.removeOperationAsync(K key)
protected RFuture<Boolean>	RedissonTransactionalMapCache.removeOperationAsync(Object key, Object value)
protected RFuture<V>	RedissonTransactionalMapCache.removeOperationAsync(K key)
RFuture<V>	BaseTransactionalSet.removeRandomAsync()
RFuture<Set<V>>	BaseTransactionalSet.removeRandomAsync(int amount)
RFuture<V>	RedissonTransactionalSet.removeRandomAsync()
RFuture<Set<V>>	RedissonTransactionalSet.removeRandomAsync(int amount)
protected RFuture<V>	BaseTransactionalMap.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	BaseTransactionalMap.replaceOperationAsync(K key, V oldValue, V newValue)
protected RFuture<V>	RedissonTransactionalMap.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonTransactionalMap.replaceOperationAsync(K key, V oldValue, V newValue)
protected RFuture<V>	RedissonTransactionalMapCache.replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	RedissonTransactionalMapCache.replaceOperationAsync(K key, V oldValue, V newValue)
RFuture<Boolean>	BaseTransactionalSet.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransactionalSet.retainAllAsync(Collection<?> c)
RFuture<Boolean>	RedissonTransactionalSetCache.retainAllAsync(Collection<?> c)
RFuture<Void>	RedissonTransaction.rollbackAsync()
RFuture<Void>	RedissonTransactionalBucket.setAsync(V newValue)
RFuture<Void>	RedissonTransactionalBucket.setAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Void>	RedissonTransactionalBuckets.setAsync(Map<String,?> buckets)
RFuture<Void>	RedissonTransactionalMapCache.setMaxSizeAsync(int maxSize)
RFuture<Long>	RedissonTransactionalBucket.sizeAsync()
RFuture<Integer>	BaseTransactionalSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Integer>	RedissonTransactionalSet.sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count)
RFuture<Boolean>	BaseTransactionalMap.touchAsync(CommandAsyncExecutor commandExecutor)
RFuture<Boolean>	BaseTransactionalSet.touchAsync()
RFuture<Boolean>	RedissonTransactionalBucket.touchAsync()
RFuture<Boolean>	RedissonTransactionalMap.touchAsync()
RFuture<Boolean>	RedissonTransactionalMapCache.touchAsync()
RFuture<Boolean>	RedissonTransactionalSet.touchAsync()
RFuture<Boolean>	RedissonTransactionalSetCache.touchAsync()
RFuture<Boolean>	RedissonTransactionalBucket.trySetAsync(V newValue)
RFuture<Boolean>	RedissonTransactionalBucket.trySetAsync(V value, long timeToLive, TimeUnit timeUnit)
RFuture<Boolean>	RedissonTransactionalBuckets.trySetAsync(Map<String,?> buckets)
RFuture<Boolean>	RedissonTransactionalMapCache.trySetMaxSizeAsync(int maxSize)
RFuture<Integer>	BaseTransactionalSet.unionAsync(String... names)
RFuture<Integer>	RedissonTransactionalSet.unionAsync(String... names)
RFuture<Boolean>	BaseTransactionalMap.unlinkAsync(CommandAsyncExecutor commandExecutor)
RFuture<Boolean>	BaseTransactionalSet.unlinkAsync()
RFuture<Boolean>	RedissonTransactionalBucket.unlinkAsync()
RFuture<Boolean>	RedissonTransactionalMap.unlinkAsync()
RFuture<Boolean>	RedissonTransactionalMapCache.unlinkAsync()
RFuture<Boolean>	RedissonTransactionalSet.unlinkAsync()
RFuture<Boolean>	RedissonTransactionalSetCache.unlinkAsync()
RFuture<Integer>	BaseTransactionalMap.valueSizeAsync(K key)
RFuture<Integer>	RedissonTransactionalMap.valueSizeAsync(K key)
RFuture<Integer>	RedissonTransactionalMapCache.valueSizeAsync(K key)

Uses of RFuture in org.redisson.transaction.operation

Methods in org.redisson.transaction.operation that return RFuture

Modifier and Type	Method	Description
RFuture<Boolean>	ExpireOperation.RedissonBucketExtended.expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
protected RFuture<Boolean>	ExpireAtOperation.RedissonBucketExtended.expireAtAsync(long timestamp, String param, String... keys)