Package org.apache.cassandra.utils.concurrent

Interface Summary

Interface	Description
Awaitable	A generic signal consumer, supporting all of the typical patterns used in Cassandra.
Condition	Simpler API than java.util.concurrent.Condition; would be nice to extend it, but also nice to share API with Future, for which Netty's API is incompatible with java.util.concurrent.Condition Awaitable for explicit external signals.
ConditionAsConsumer<T>
CountDownLatch
Future<V>	A Future that integrates several different (but equivalent) APIs used within Cassandra into a single concept, integrating also with our Awaitable abstraction, to overall improve coherency and clarity in the codebase.
IntrusiveStack.Setter<O,T>
Promise<V>	A Promise that integrates Promise with our Future API to improve clarity and coherence in the codebase.
Ref.OnLeak
RefCounted<T>	An object that needs ref counting does the two following: - defines a Tidy object that will cleanup once it's gone, (this must retain no references to the object we're tracking (only its resources and how to clean up)) Then, one of two options: 1) Construct a Ref directly pointing to it, and always use this Ref; or 2) - implements RefCounted - encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours - users must ensure no references to the selfRef leak, or are retained outside of a method scope.
RefCounted.Tidy
RunnableFuture<V>
SelfRefCounted<T extends SelfRefCounted<T>>
Semaphore
SharedCloseable	A simple extension of AutoCloseable, that represents a resource that can be utilised in multiple locations, each managing their own closure of the resource, so that when the last such instance is closed all are.
Transactional	An abstraction for Transactional behaviour.
WaitQueue	A relatively easy to use utility for general purpose thread signalling.
WaitQueue.Signal	A Signal is a one-time-use mechanism for a thread to wait for notification that some condition state has transitioned that it may be interested in (and hence should check if it is).
WeightedQueue.Weighable
WeightedQueue.Weigher<T>

Class Summary

Class	Description
AbstractFuture<V>	Our default Future implementation, with all state being managed without locks (except those used by the JVM).
Accumulator<E>	A simple append-only collection supporting an unbounded number of concurrent readers/writers, but a bounded number of items.
AsyncFuture<V>	Our default Future implementation, with all state being managed without locks (except those used by the JVM).
AsyncPromise<V>	Extends AsyncFuture to implement the Promise interface.
AsyncPromise.WithExecutor<V>
Awaitable.AbstractAwaitable
Awaitable.AsyncAwaitable	A barebones asynchronous Awaitable.
Awaitable.Defaults
Awaitable.SyncAwaitable	A barebones Awaitable that uses mutual exclusion.
BlockingQueues
BlockingQueues.Sync<T>
Condition.Async	An asynchronous Condition.
Condition.Sync	A Condition based on its object monitor.
ConditionAsConsumer.Async<T>
CountDownLatch.Async
CountDownLatch.Sync
FutureCombiner<T>	Netty's PromiseCombiner is not threadsafe, and we combine futures from multiple event executors.
ImmediateFuture<V>
IntrusiveStack<T extends IntrusiveStack<T>>	An efficient stack/list that is expected to be ordinarily either empty or close to, and for which we need concurrent insertions and do not need to support removal - i.e.
LoadingMap<K,V>	An extension of NonBlockingHashMap where all values are wrapped by Future.
NonBlockingRateLimiter	A rate limiter implementation that allows callers to reserve permits that may only be available in the future, delegating to them decisions about how to schedule/delay work and whether or not to block execution to do so.
NotScheduledFuture<T>
OpOrder	A class for providing synchronization between producers and consumers that do not communicate directly with each other, but where the consumers need to process their work in contiguous batches.
OpOrder.Group	Represents a group of identically ordered operations, i.e.
Ref<T>	An object that needs ref counting does the two following: - defines a Tidy object that will cleanup once it's gone, (this must retain no references to the object we're tracking (only its resources and how to clean up)) Then, one of two options: 1) Construct a Ref directly pointing to it, and always use this Ref; or 2) - implements RefCounted - encapsulates a Ref, we'll call selfRef, to which it proxies all calls to RefCounted behaviours - users must ensure no references to the selfRef leak, or are retained outside of a method scope.
Ref.IdentityCollection
Refs<T extends RefCounted<T>>	A collection of managed Ref references to RefCounted objects, and the objects they are referencing.
Semaphore.Standard
SharedCloseableImpl	A simple abstract implementation of SharedCloseable
SyncFuture<V>	Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads.
SyncPromise<V>	Extends SyncFuture to implement the Promise interface.
SyncPromise.WithExecutor<V>
Threads
Threads.StackTraceCombiner
Transactional.AbstractTransactional	A simple abstract implementation of Transactional behaviour.
WaitQueue.Standard
WaitQueue.Standard.AbstractSignal	An abstract signal implementation TODO: use intrusive linked list
WeightedQueue<T>	Weighted queue is a wrapper around any blocking queue that turns it into a blocking weighted queue.
WrappedSharedCloseable	An implementation of SharedCloseable that wraps a normal AutoCloseable, ensuring its close method is only called when all instances of SharedCloseable have been

Enum Summary

Enum	Description
Transactional.AbstractTransactional.State

Exception Summary

Exception	Description
LoadingMap.UnloadExecutionException	Thrown when unloading a value failed.
UncheckedInterruptedException	Unchecked InterruptedException, to be thrown in places where an interrupt is unexpected