Uses of Interface
org.redisson.api.RObjectAsync

Packages that use RObjectAsync

Package	Description
org.redisson
org.redisson.api
org.redisson.jcache
org.redisson.transaction

Uses of RObjectAsync in org.redisson

Classes in org.redisson that implement RObjectAsync

Modifier and Type	Class	Description
class	RedissonAtomicDouble	Distributed alternative to the AtomicLong
class	RedissonAtomicLong	Distributed alternative to the AtomicLong
class	RedissonBaseAdder<T extends Number>
class	RedissonBinaryStream
class	RedissonBitSet
class	RedissonBlockingDeque<V>	Distributed and concurrent implementation of BlockingDeque.
class	RedissonBlockingQueue<V>	Distributed and concurrent implementation of BlockingQueue.
class	RedissonBloomFilter<T>	Bloom filter based on Highway 128-bit hash.
class	RedissonBoundedBlockingQueue<V>	Distributed and concurrent implementation of bounded BlockingQueue.
class	RedissonBucket<V>
class	RedissonCountDownLatch	Distributed alternative to the CountDownLatch It has a advantage over CountDownLatch -- count can be reset via RedissonCountDownLatch.trySetCount(long).
class	RedissonDelayedQueue<V>
class	RedissonDeque<V>	Distributed and concurrent implementation of Queue
class	RedissonDoubleAdder
class	RedissonFairLock	Distributed implementation of Lock Implements reentrant lock. Lock will be removed automatically if client disconnects.
class	RedissonGeo<V>	Geospatial items holder
class	RedissonHyperLogLog<V>
class	RedissonLexSortedSet	Sorted set contained values of String type
class	RedissonList<V>	Distributed and concurrent implementation of List
class	RedissonListMultimap<K,V>
class	RedissonListMultimapCache<K,V>
class	RedissonListMultimapValues<V>	List based Multimap Cache values holder
class	RedissonLocalCachedMap<K,V>
class	RedissonLock	Distributed implementation of Lock Implements reentrant lock. Lock will be removed automatically if client disconnects.
class	RedissonLongAdder
class	RedissonMap<K,V>	Distributed and concurrent implementation of ConcurrentMap and Map
class	RedissonMapCache<K,V>	Map-based cache with ability to set TTL for each entry via RedissonMapCache.put(Object, Object, long, TimeUnit) or RedissonMapCache.putIfAbsent(Object, Object, long, TimeUnit) methods.
class	RedissonMultimap<K,V>
class	RedissonObject	Base Redisson object
class	RedissonPermitExpirableSemaphore
class	RedissonPriorityBlockingDeque<V>	Distributed and concurrent implementation of priority blocking deque.
class	RedissonPriorityBlockingQueue<V>	Distributed and concurrent implementation of PriorityBlockingQueue.
class	RedissonPriorityDeque<V>	Distributed and concurrent implementation of Queue
class	RedissonPriorityQueue<V>
class	RedissonQueue<V>	Distributed and concurrent implementation of Queue
class	RedissonQueueSemaphore
class	RedissonRateLimiter
class	RedissonReadLock	Lock will be removed automatically if client disconnects.
class	RedissonReadWriteLock	A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.
class	RedissonScoredSortedSet<V>
class	RedissonSemaphore	Distributed and concurrent implementation of Semaphore.
class	RedissonSet<V>	Distributed and concurrent implementation of Set
class	RedissonSetCache<V>	Set-based cache with ability to set TTL for each entry via RSetCache.add(Object, long, TimeUnit) method.
class	RedissonSetMultimap<K,V>
class	RedissonSetMultimapCache<K,V>
class	RedissonSetMultimapValues<V>	Set based Multimap Cache values holder
class	RedissonSortedSet<V>
class	RedissonStream<K,V>
class	RedissonSubList<V>	Distributed and concurrent implementation of List
class	RedissonWriteLock	Lock will be removed automatically if client disconnects.

Uses of RObjectAsync in org.redisson.api

Subinterfaces of RObjectAsync in org.redisson.api

Modifier and Type	Interface	Description
interface	RAtomicDouble	Distributed implementation to the AtomicDouble
interface	RAtomicDoubleAsync	Distributed implementation to the AtomicDouble
interface	RAtomicLong	Distributed implementation of AtomicLong
interface	RAtomicLongAsync	Distributed async implementation of AtomicLong
interface	RBinaryStream	Binary stream holder.
interface	RBitSet	Vector of bits that grows as needed.
interface	RBitSetAsync	Vector of bits that grows as needed.
interface	RBlockingDeque<V>	BlockingDeque backed by Redis
interface	RBlockingDequeAsync<V>	Distributed async implementation of BlockingDeque
interface	RBlockingQueue<V>	Distributed implementation of BlockingQueue
interface	RBlockingQueueAsync<V>	Distributed async implementation of BlockingQueue
interface	RBloomFilter<T>	Distributed implementation of Bloom filter based on Highway 128-bit hash.
interface	RBoundedBlockingQueue<V>	Distributed implementation of bounded BlockingQueue
interface	RBoundedBlockingQueueAsync<V>	Distributed async implementation of bounded BlockingQueue
interface	RBucket<V>	Object holder.
interface	RBucketAsync<V>	Async implementation of object holder.
interface	RCollectionAsync<V>	Common async interface for collection object
interface	RCountDownLatch	Distributed implementation of CountDownLatch It has an advantage over CountDownLatch -- count can be set via RCountDownLatch.trySetCount(long) method.
interface	RCountDownLatchAsync	Distributed async implementation of CountDownLatch It has an advantage over CountDownLatch -- count can be set via RCountDownLatchAsync.trySetCountAsync(long) method.
interface	RDelayedQueue<V>	Distributed implementation of delayed queue.
interface	RDeque<V>	Distributed implementation of Deque
interface	RDequeAsync<V>	Distributed async implementation of Deque
interface	RDoubleAdder	Distributed implementation of DoubleAdder
interface	RExpirable	Base interface for all Redisson objects which support expiration or TTL
interface	RExpirableAsync	Base async interface for all Redisson objects which supports expiration (TTL)
interface	RGeo<V>	Geospatial items holder.
interface	RGeoAsync<V>	Geospatial items holder.
interface	RHyperLogLog<V>	Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
interface	RHyperLogLogAsync<V>	Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
interface	RLexSortedSet	Sorted set contained values of String type
interface	RLexSortedSetAsync	Sorted set contained values of String type
interface	RList<V>	Distributed and concurrent implementation of List
interface	RListAsync<V>	Async list functions
interface	RListMultimap<K,V>	List based Multimap.
interface	RListMultimapCache<K,V>
interface	RLocalCachedMap<K,V>	Map object with local entry cache support.
interface	RLock	Distributed implementation of Lock Implements reentrant lock.
interface	RLockAsync	Distributed implementation of Lock
interface	RLongAdder	Distributed implementation of LongAdder
interface	RMap<K,V>	Distributed implementation of ConcurrentMap and Map This map doesn't allow to store null as key or value.
interface	RMapAsync<K,V>	Distributed async implementation of Map.
interface	RMapCache<K,V>	Map-based cache with ability to set TTL for each entry via RMapCache.put(Object, Object, long, TimeUnit) or RMapCache.putIfAbsent(Object, Object, long, TimeUnit) And therefore has an complex lua-scripts inside.
interface	RMapCacheAsync<K,V>	Map-based cache with ability to set TTL for each entry via RMapCache.put(Object, Object, long, TimeUnit) or RMapCache.putIfAbsent(Object, Object, long, TimeUnit) And therefore has an complex lua-scripts inside.
interface	RMultimap<K,V>	Base Multimap interface.
interface	RMultimapAsync<K,V>	Base asynchronous MultiMap interface.
interface	RMultimapCache<K,V>
interface	RMultimapCacheAsync<K,V>
interface	RObject	Base interface for all Redisson objects
interface	RPermitExpirableSemaphore	Semaphore object with lease time parameter support for each acquired permit.
interface	RPermitExpirableSemaphoreAsync	Semaphore object with support of lease time parameter for each acquired permit.
interface	RPriorityBlockingDeque<V>	RPriorityBlockingDeque backed by Redis
interface	RPriorityBlockingQueue<V>	PriorityBlockingQueue backed by Redis
interface	RPriorityDeque<V>
interface	RPriorityQueue<V>
interface	RQueue<V>	Queue backed by Redis
interface	RQueueAsync<V>	Queue backed by Redis
interface	RRateLimiter
interface	RRateLimiterAsync
interface	RScoredSortedSet<V>
interface	RScoredSortedSetAsync<V>
interface	RSemaphore	Distributed and concurrent implementation of Semaphore.
interface	RSemaphoreAsync	Distributed and concurrent implementation of Semaphore.
interface	RSet<V>	Distributed and concurrent implementation of Set
interface	RSetAsync<V>	Async set functions
interface	RSetCache<V>	Set-based cache with ability to set TTL for each object.
interface	RSetCacheAsync<V>	Async set functions
interface	RSetMultimap<K,V>	Set based Multimap.
interface	RSetMultimapCache<K,V>
interface	RSortedSet<V>
interface	RStream<K,V>	Interface for Redis Stream object.
interface	RStreamAsync<K,V>	Async interface for Redis Stream object.

Uses of RObjectAsync in org.redisson.jcache

Classes in org.redisson.jcache that implement RObjectAsync

Modifier and Type	Class	Description
class	JCache<K,V>	JCache implementation

Uses of RObjectAsync in org.redisson.transaction

Classes in org.redisson.transaction that implement RObjectAsync

Modifier and Type	Class	Description
class	RedissonTransactionalBucket<V>
class	RedissonTransactionalLocalCachedMap<K,V>
class	RedissonTransactionalLock
class	RedissonTransactionalMap<K,V>
class	RedissonTransactionalMapCache<K,V>
class	RedissonTransactionalSet<V>
class	RedissonTransactionalSetCache<V>