#Util.concurrent Classes and Interfaces

_{#Util.concurrent Classes and Interfaces - 400 results found.}

Name	Description	Type	Package	Framework
AbstractExecutorService	Provides default implementations of ExecutorService execution methods.	Class	java.util.concurrent	Java SE
AbstractOwnableSynchronizer	A synchronizer that may be exclusively owned by a thread.	Class	java.util.concurrent.locks	Java SE
AbstractQueuedLongSynchronizer	A version of AbstractQueuedSynchronizer in which synchronization state is maintained as a long.	Class	java.util.concurrent.locks	Java SE
AbstractQueuedSynchronizer	Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on	Class	java.util.concurrent.locks	Java SE
ArrayBlockingQueue	A bounded blocking queue backed by an array.	Class	java.util.concurrent	Java SE
AtomicBoolean	A boolean value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicInteger	An int value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicIntegerArray	An int array in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicIntegerFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile int fields of designated classes.	Class	java.util.concurrent.atomic	Java SE
AtomicLong	A long value that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicLongArray	A long array in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicLongFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile long fields of designated classes.	Class	java.util.concurrent.atomic	Java SE
AtomicMarkableReference	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReference	An object reference that may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReferenceArray	An array of object references in which elements may be updated atomically.	Class	java.util.concurrent.atomic	Java SE
AtomicReferenceFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile reference fields of designated	Class	java.util.concurrent.atomic	Java SE
AtomicStampedReference	An AtomicStampedReference maintains an object reference along with an integer stamp, that can be updated atomically.	Class	java.util.concurrent.atomic	Java SE
BrokenBarrierException	Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread	Class	java.util.concurrent	Java SE
BlockingDeque	A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for	Interface	java.util.concurrent	Java SE
BlockingQueue	A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an	Interface	java.util.concurrent	Java SE
CancellationException	Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task	Class	java.util.concurrent	Java SE
CompletableFuture	A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage,	Class	java.util.concurrent	Java SE
CompletionException	Exception thrown when an error or other exception is encountered in the course of completing a result or task.	Class	java.util.concurrent	Java SE
ConcurrentHashMap	A hash table supporting full concurrency of retrievals and high expected concurrency for updates.	Class	java.util.concurrent	Java SE
ConcurrentHashMap .KeySetView	A view of a ConcurrentHashMap as a Set of keys, in which additions may optionally be enabled by mapping to a	Class	java.util.concurrent.ConcurrentHashMap	Java SE
ConcurrentLinkedDeque	An unbounded concurrent deque based on linked nodes.	Class	java.util.concurrent	Java SE
ConcurrentLinkedQueue	An unbounded thread-safe queue based on linked nodes.	Class	java.util.concurrent	Java SE
ConcurrentModificationException	This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.	Class	java.util	Java SE
ConcurrentSkipListMap	A scalable concurrent ConcurrentNavigableMap implementation.	Class	java.util.concurrent	Java SE
ConcurrentSkipListSet	A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.	Class	java.util.concurrent	Java SE
CopyOnWriteArrayList	A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by	Class	java.util.concurrent	Java SE
CopyOnWriteArraySet	A Set that uses an internal CopyOnWriteArrayList for all of its operations.	Class	java.util.concurrent	Java SE
CountDownLatch	A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.	Class	java.util.concurrent	Java SE
CountedCompleter	A ForkJoinTask with a completion action performed when triggered and there are no remaining pending actions.	Class	java.util.concurrent	Java SE
CyclicBarrier	A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.	Class	java.util.concurrent	Java SE
Callable	A task that returns a result and may throw an exception.	Interface	java.util.concurrent	Java SE
CompletableFuture .AsynchronousCompletionTask	A marker interface identifying asynchronous tasks produced by async methods.	Interface	java.util.concurrent.CompletableFuture	Java SE
CompletionService	A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.	Interface	java.util.concurrent	Java SE
CompletionStage	A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.	Interface	java.util.concurrent	Java SE
ConcurrentMap	A Map providing thread safety and atomicity To maintain the specified guarantees, default implementations of	Interface	java.util.concurrent	Java SE
ConcurrentNavigableMap	A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.	Interface	java.util.concurrent	Java SE
Condition	Condition factors out the Object monitor methods (wait, notify	Interface	java.util.concurrent.locks	Java SE
DelayQueue	An unbounded blocking queue of Delayed elements, in which an element can only be taken	Class	java.util.concurrent	Java SE
DoubleAccumulator	One or more variables that together maintain a running double value updated using a supplied function.	Class	java.util.concurrent.atomic	Java SE
DoubleAdder	One or more variables that together maintain an initially zero double sum.	Class	java.util.concurrent.atomic	Java SE
Delayed	A mix-in style interface for marking objects that should be acted upon after a given delay.	Interface	java.util.concurrent	Java SE
Exchanger	A synchronization point at which threads can pair and swap elements within pairs.	Class	java.util.concurrent	Java SE
ExecutionException	Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.	Class	java.util.concurrent	Java SE
ExecutorCompletionService	A CompletionService that uses a supplied Executor to execute tasks.	Class	java.util.concurrent	Java SE
Executors	Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package.	Class	java.util.concurrent	Java SE
Executor	An object that executes submitted Runnable tasks.	Interface	java.util.concurrent	Java SE
ExecutorService	An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of	Interface	java.util.concurrent	Java SE
Flow	Interrelated interfaces and static methods for establishing flow-controlled components in which Publishers	Class	java.util.concurrent	Java SE
ForkJoinPool	An ExecutorService for running ForkJoinTasks.	Class	java.util.concurrent	Java SE
ForkJoinTask	Abstract base class for tasks that run within a ForkJoinPool.	Class	java.util.concurrent	Java SE
ForkJoinWorkerThread	A thread managed by a ForkJoinPool, which executes This class is subclassable solely for the sake of adding	Class	java.util.concurrent	Java SE
FutureTask	A cancellable asynchronous computation.	Class	java.util.concurrent	Java SE
Flow .Processor	A component that acts as both a Subscriber and Publisher.	Interface	java.util.concurrent.Flow	Java SE
Flow .Publisher	A producer of items (and related control messages) received by Subscribers.	Interface	java.util.concurrent.Flow	Java SE
Flow .Subscriber	A receiver of messages.	Interface	java.util.concurrent.Flow	Java SE
Flow .Subscription	Message control linking a Flow.	Interface	java.util.concurrent.Flow	Java SE
ForkJoinPool .ForkJoinWorkerThreadFactory	Factory for creating new ForkJoinWorkerThreads.	Interface	java.util.concurrent.ForkJoinPool	Java SE
ForkJoinPool .ManagedBlocker	A ManagedBlocker provides two methods.	Interface	java.util.concurrent.ForkJoinPool	Java SE
Future	A Future represents the result of an asynchronous computation.	Interface	java.util.concurrent	Java SE
LinkedBlockingDeque	An optionally-bounded blocking deque based on The optional capacity bound constructor argument serves as a	Class	java.util.concurrent	Java SE
LinkedBlockingQueue	An optionally-bounded blocking queue based on This queue orders elements FIFO (first-in-first-out).	Class	java.util.concurrent	Java SE
LinkedTransferQueue	An unbounded TransferQueue based on linked nodes.	Class	java.util.concurrent	Java SE
LockSupport	Basic thread blocking primitives for creating locks and other synchronization classes.	Class	java.util.concurrent.locks	Java SE
LongAccumulator	One or more variables that together maintain a running long value updated using a supplied function.	Class	java.util.concurrent.atomic	Java SE
LongAdder	One or more variables that together maintain an initially zero long sum.	Class	java.util.concurrent.atomic	Java SE
Lock	Lock implementations provide more extensive locking operations than can be obtained using synchronized methods	Interface	java.util.concurrent.locks	Java SE
Phaser	A reusable synchronization barrier, similar in functionality to but supporting more flexible usage.	Class	java.util.concurrent	Java SE
PriorityBlockingQueue	An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies	Class	java.util.concurrent	Java SE
RecursiveAction	A recursive resultless ForkJoinTask.	Class	java.util.concurrent	Java SE
RecursiveTask	A recursive result-bearing ForkJoinTask.	Class	java.util.concurrent	Java SE
ReentrantLock	A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using	Class	java.util.concurrent.locks	Java SE
ReentrantReadWriteLock	An implementation of ReadWriteLock supporting similar semantics to ReentrantLock.	Class	java.util.concurrent.locks	Java SE
ReentrantReadWriteLock .ReadLock	The lock returned by method ReentrantReadWriteLock.	Class	java.util.concurrent.locks.ReentrantReadWriteLock	Java SE
ReentrantReadWriteLock .WriteLock	The lock returned by method ReentrantReadWriteLock.	Class	java.util.concurrent.locks.ReentrantReadWriteLock	Java SE
RejectedExecutionException	Exception thrown by an Executor when a task cannot be accepted for execution.	Class	java.util.concurrent	Java SE
ReadWriteLock	A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing.	Interface	java.util.concurrent.locks	Java SE
RejectedExecutionHandler	A handler for tasks that cannot be executed by a ThreadPoolExecutor.	Interface	java.util.concurrent	Java SE
RunnableFuture	A Future that is Runnable.	Interface	java.util.concurrent	Java SE
RunnableScheduledFuture	A ScheduledFuture that is Runnable.	Interface	java.util.concurrent	Java SE
ScheduledThreadPoolExecutor	A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.	Class	java.util.concurrent	Java SE
Semaphore	A counting semaphore.	Class	java.util.concurrent	Java SE
StampedLock	A capability-based lock with three modes for controlling read/write access.	Class	java.util.concurrent.locks	Java SE
SubmissionPublisher	A Flow.	Class	java.util.concurrent	Java SE
SynchronousQueue	A blocking queue in which each insert operation must wait for a corresponding remove operation by another	Class	java.util.concurrent	Java SE
ScheduledExecutorService	An ExecutorService that can schedule commands to run after a given delay, or to execute periodically.	Interface	java.util.concurrent	Java SE
ScheduledFuture	A delayed result-bearing action that can be cancelled.	Interface	java.util.concurrent	Java SE
ThreadLocalRandom	A random number generator isolated to the current thread.	Class	java.util.concurrent	Java SE
ThreadPoolExecutor	An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured	Class	java.util.concurrent	Java SE
ThreadPoolExecutor .AbortPolicy	A handler for rejected tasks that throws a RejectedExecutionException.	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .CallerRunsPolicy	A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method,	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .DiscardOldestPolicy	A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor	Class	java.util.concurrent.ThreadPoolExecutor	Java SE
ThreadPoolExecutor .DiscardPolicy		Class	java.util.concurrent.ThreadPoolExecutor	Java SE
TimeoutException	Exception thrown when a blocking operation times out.	Class	java.util.concurrent	Java SE
TimeUnit	A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units,	Class	java.util.concurrent	Java SE
ThreadFactory	An object that creates new threads on demand.	Interface	java.util.concurrent	Java SE
TransferQueue	A BlockingQueue in which producers may wait for consumers to receive elements.	Interface	java.util.concurrent	Java SE
CompletableToListenableFutureAdapter	Adapts a CompletableFuture into a ListenableFuture.	Class	org.springframework.util.concurrent	Spring MVC
ConcurrentReferenceHashMap	A ConcurrentHashMap that uses soft orweak references for both keys and values.	Class	org.springframework.util	Spring MVC
ConcurrentReferenceHashMap .Entry		Class	org.springframework.util.ConcurrentReferenceHashMap	Spring MVC
ConcurrentReferenceHashMap .Reference	A reference to an ConcurrentReferenceHashMap.	Interface	org.springframework.util.ConcurrentReferenceHashMap	Spring MVC
ConcurrentReferenceHashMap .ReferenceType	Various reference types supported by this map.	Class	org.springframework.util.ConcurrentReferenceHashMap	Spring MVC
ConcurrentReferenceHashMap .Restructure	The types of restructuring that can be performed.	Class	org.springframework.util.ConcurrentReferenceHashMap	Spring MVC
FailureCallback	Defines the contract for failure callbacks that accept the result of aSince:4.	Interface	org.springframework.util.concurrent	Spring MVC
FutureAdapter	Abstract class that adapts a Future parameterized over S into a Future parameterized over T.	Class	org.springframework.util.concurrent	Spring MVC
ListenableFuture	callbacks.	Interface	org.springframework.util.concurrent	Spring MVC
ListenableFutureAdapter	Abstract class that adapts a ListenableFuture parameterized over S into aListenableFuture parameterized over T.	Class	org.springframework.util.concurrent	Spring MVC
ListenableFutureCallback	Defines the contract for callbacks that accept the result of aSince:4.	Interface	org.springframework.util.concurrent	Spring MVC
ListenableFutureCallbackRegistry	Registry for ListenableFutureCallback instances.	Class	org.springframework.util.concurrent	Spring MVC
ListenableFutureTask	Extension of FutureTask that implements ListenableFuture.	Class	org.springframework.util.concurrent	Spring MVC
SettableListenableFuture	whose value can be set via set(Object) orsetException(Throwable).	Class	org.springframework.util.concurrent	Spring MVC
SuccessCallback	Defines the contract for success callbacks that accept the result of aSince:4.	Interface	org.springframework.util.concurrent	Spring MVC
ConcurrentCache		Class	org.zkoss.zel.impl.util	ZKoss (ZK)
ConcurrentHashSet	This class implements the Set interface, backed by a ConcurrentHashMap instance.	Class	org.jivesoftware.util	Echo
ConcurrentBarrier	A barrier used to execute code in a context where it is guarded by read/write locks.	Class	org.apache.tapestry5.ioc.internal.util	Apache Tapestry
AtomicException	Convenience class for holding an Exception in a thread-safe waySee Also:Serialized Form	Class	org.apache.camel.util.concurrent	Apache Camel
AtomicExchange	Convenience class for holding an Exchange in a thread-safe waySee Also:Serialized Form	Class	org.apache.camel.util.concurrent	Apache Camel
CamelThreadFactory	Thread factory which creates threads supporting a naming pattern.	Class	org.apache.camel.util.concurrent	Apache Camel
RejectableFutureTask	A Rejectable FutureTask used by RejectableThreadPoolExecutor.	Class	org.apache.camel.util.concurrent	Apache Camel
RejectableScheduledThreadPoolExecutor	Scheduled thread pool executor that creates RejectableFutureTask instead of FutureTask when registering new tasks for execution.	Class	org.apache.camel.util.concurrent	Apache Camel
RejectableThreadPoolExecutor	Thread pool executor that creates RejectableFutureTask instead of FutureTask when registering new tasks for execution.	Class	org.apache.camel.util.concurrent	Apache Camel
SizedScheduledExecutorService	A sized ScheduledExecutorService which will reject executing tasks if the task queue is full.	Class	org.apache.camel.util.concurrent	Apache Camel
SubmitOrderedCompletionService	A CompletionService that orders the completed tasks in the same order as they where submitted.	Class	org.apache.camel.util.concurrent	Apache Camel
SynchronousExecutorService	A synchronous ExecutorService which always invokes the task in the caller thread (just a thread pool facade).	Class	org.apache.camel.util.concurrent	Apache Camel
ThreadHelper	Various helper method for thread naming.	Class	org.apache.camel.util.concurrent	Apache Camel
ConcurrentLFUCache	A LFU cache implementation based upon ConcurrentHashMap.	Class	org.apache.solr.util	Apache Solr Lucene
ConcurrentLFUCache .EvictionListener		Interface	org.apache.solr.util.ConcurrentLFUCache	Apache Solr Lucene
ConcurrentLFUCache .Stats		Class	org.apache.solr.util.ConcurrentLFUCache	Apache Solr Lucene
ConcurrentLRUCache	A LRU cache implementation based upon ConcurrentHashMap and other techniques to reduce contention and synchronization overhead to utilize multiple CPU cores more effectively.	Class	org.apache.solr.util	Apache Solr Lucene
ConcurrentLRUCache .EvictionListener		Interface	org.apache.solr.util.ConcurrentLRUCache	Apache Solr Lucene
ConcurrentLRUCache .Stats		Class	org.apache.solr.util.ConcurrentLRUCache	Apache Solr Lucene
BoundedBuffer	Efficient array-based bounded buffer class.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
BoundedChannel	A channel that is known to have a capacity, signifying that put operations may block when the	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
BoundedLinkedQueue	A bounded variant of class.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
Channel	Main interface for buffers, queues, pipes, conduits, etc.	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
DefaultChannelCapacity	A utility class to set the default capacity of implementations that otherwise require a capacity argument	Class	org.dbunit.util.concurrent	SourceForge DBUnit
Executor	Interface for objects that execute Runnables, as well as various objects that can be wrapped	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
LinkedNode	A standard linked list node used in various queue classesSince:? (pre 2.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
LinkedQueue	A linked list based channel implementation.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
PropertyChangeMulticaster	This class is interoperable with java.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
Puttable	This interface exists to enable stricter type checking for channels.	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
Semaphore	Base class for counting semaphores.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
SemaphoreControlledChannel	Abstract class for channels that use Semaphores to control puts and takes.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
Slot	A one-slot buffer, using semaphores to control access.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
Sync	Main interface for locks, gates, and conditions.	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
SynchronizedInt	A class useful for offloading synch for int instance variables.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
SynchronizedVariable	Base class for simple, small classes maintaining single values that are always accessed	Class	org.dbunit.util.concurrent	SourceForge DBUnit
SynchronousChannel	A rendezvous channel, similar to those used in CSP and Ada.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
SynchronousChannel .Queue	Simple FIFO queue class to hold waiting puts/takes.	Class	org.dbunit.util.concurrent.SynchronousChannel	SourceForge DBUnit
Takable	This interface exists to enable stricter type checking for channels.	Interface	org.dbunit.util.concurrent	SourceForge DBUnit
TimeoutException	Thrown by synchronization classes that report timeouts via exceptions.	Class	org.dbunit.util.concurrent	SourceForge DBUnit
AbstractExecutorService	Provides default implementations of ExecutorService execution methods.	Class	util.concurrent	Code Trails
AbstractOwnableSynchronizer	A synchronizer that may be exclusively owned by a thread.	Class	util.concurrent.locks	Code Trails
AbstractQueuedLongSynchronizer	A version of AbstractQueuedSynchronizer in which synchronization state is maintained as a long.	Class	util.concurrent.locks	Code Trails
AbstractQueuedLongSynchronizer .Node		Class	util.concurrent.locks.AbstractQueuedLongSynchronizer	Code Trails
AbstractQueuedSynchronizer	Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on	Class	util.concurrent.locks	Code Trails
AbstractQueuedSynchronizer .Node		Class	util.concurrent.locks.AbstractQueuedSynchronizer	Code Trails
ArrayBlockingQueue	A bounded blocking queue backed by an array.	Class	util.concurrent	Code Trails
AtomicBoolean	A boolean value that may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicInteger	An int value that may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicIntegerArray	An int array in which elements may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicIntegerFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile int fields of designated classes.	Class	util.concurrent.atomic	Code Trails
AtomicIntegerFieldUpdater .AtomicIntegerFieldUpdaterImpl		Class	util.concurrent.atomic.AtomicIntegerFieldUpdater	Code Trails
AtomicLong	A long value that may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicLongArray	A long array in which elements may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicLongFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile long fields of designated classes.	Class	util.concurrent.atomic	Code Trails
AtomicLongFieldUpdater .CASUpdater		Class	util.concurrent.atomic.AtomicLongFieldUpdater	Code Trails
AtomicLongFieldUpdater .LockedUpdater		Class	util.concurrent.atomic.AtomicLongFieldUpdater	Code Trails
AtomicMarkableReference	An AtomicMarkableReference maintains an object reference along with a mark bit, that can be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicMarkableReference .Pair		Class	util.concurrent.atomic.AtomicMarkableReference	Code Trails
AtomicReference	An object reference that may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicReferenceArray	An array of object references in which elements may be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicReferenceFieldUpdater	A reflection-based utility that enables atomic updates to designated volatile reference fields of designated	Class	util.concurrent.atomic	Code Trails
AtomicReferenceFieldUpdater .AtomicReferenceFieldUpdaterImpl		Class	util.concurrent.atomic.AtomicReferenceFieldUpdater	Code Trails
AtomicStampedReference	An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.	Class	util.concurrent.atomic	Code Trails
AtomicStampedReference .Pair		Class	util.concurrent.atomic.AtomicStampedReference	Code Trails
BlockingDeque	A Deque that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for	Interface	util.concurrent	Code Trails
BlockingQueue	A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an	Interface	util.concurrent	Code Trails
BrokenBarrierException	Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread	Class	util.concurrent	Code Trails
Callable	A task that returns a result and may throw an exception.	Interface	util.concurrent	Code Trails
CancellationException	Exception indicating that the result of a value-producing task, such as a FutureTask, cannot be retrieved because the task	Class	util.concurrent	Code Trails
CompletionService	A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.	Interface	util.concurrent	Code Trails
ConcurrentHashMap	A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.	Class	util.concurrent	Code Trails
ConcurrentHashMap .HashEntry		Class	util.concurrent.ConcurrentHashMap	Code Trails
ConcurrentHashMap .Holder	holds values which can't be initialized until after VM is booted.	Class	util.concurrent.ConcurrentHashMap	Code Trails
ConcurrentHashMap .Segment		Class	util.concurrent.ConcurrentHashMap	Code Trails
ConcurrentLinkedDeque	An unbounded concurrent deque based on linked nodes.	Class	util.concurrent	Code Trails
ConcurrentLinkedDeque .Node		Class	util.concurrent.ConcurrentLinkedDeque	Code Trails
ConcurrentLinkedQueue	An unbounded thread-safe queue based on linked nodes.	Class	util.concurrent	Code Trails
ConcurrentLinkedQueue .Node		Class	util.concurrent.ConcurrentLinkedQueue	Code Trails
ConcurrentMap	A Map providing additional atomic putIfAbsent, remove, and replace methods.	Interface	util.concurrent	Code Trails
ConcurrentModificationException	This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.	Class	util	Code Trails
ConcurrentNavigableMap	A ConcurrentMap supporting NavigableMap operations, and recursively so for its navigable sub-maps.	Interface	util.concurrent	Code Trails
ConcurrentSkipListMap	A scalable concurrent ConcurrentNavigableMap implementation.	Class	util.concurrent	Code Trails
ConcurrentSkipListMap .ComparableUsingComparator		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .EntrySet		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .HeadIndex		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .Index		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .KeySet		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .Node		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .SubMap		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListMap .Values		Class	util.concurrent.ConcurrentSkipListMap	Code Trails
ConcurrentSkipListSet	A scalable concurrent NavigableSet implementation based on a ConcurrentSkipListMap.	Class	util.concurrent	Code Trails
Condition	Condition factors out the Object monitor methods (wait, notify	Interface	util.concurrent.locks	Code Trails
CondVar	This class is designed for fans of POSIX pthreads programming.	Class	sun.corba.se.impl.orbutil.concurrent	Code Trails
CopyOnWriteArrayList	A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by	Class	util.concurrent	Code Trails
CopyOnWriteArrayList .COWIterator		Class	util.concurrent.CopyOnWriteArrayList	Code Trails
CopyOnWriteArrayList .COWSubList	Sublist for CopyOnWriteArrayList.	Class	util.concurrent.CopyOnWriteArrayList	Code Trails
CopyOnWriteArrayList .COWSubListIterator		Class	util.concurrent.CopyOnWriteArrayList	Code Trails
CopyOnWriteArraySet	A Set that uses an internal CopyOnWriteArrayList for all of its operations.	Class	util.concurrent	Code Trails
CountDownLatch	A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.	Class	util.concurrent	Code Trails
CountDownLatch .Sync	Synchronization control For CountDownLatch.	Class	util.concurrent.CountDownLatch	Code Trails
CyclicBarrier	A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.	Class	util.concurrent	Code Trails
CyclicBarrier .Generation	Each use of the barrier is represented as a generation instance.	Class	util.concurrent.CyclicBarrier	Code Trails
DebugMutex		Class	sun.corba.se.impl.orbutil.concurrent	Code Trails
Delayed	A mix-in style interface for marking objects that should be acted upon after a given delay.	Interface	util.concurrent	Code Trails
DelayQueue	An unbounded blocking queue of Delayed elements, in which an element can only be taken	Class	util.concurrent	Code Trails
AbstractInProcessFuture	An abstract Future that has completedVersion:4.	Class	org.infinispan.commons.util.concurrent	Infinispan
AbstractInProcessNotifyingFuture	An abstract NotifyingFuture that has completedVersion:4.	Class	org.infinispan.commons.util.concurrent	Infinispan
BaseNotifyingFuture		Class	org.infinispan.commons.util.concurrent	Infinispan
CompositeNotifyingFuture	CompositeNotifyingFuture aggregates several NotifyingFuture and completes when all of them complete.	Class	org.infinispan.commons.util.concurrent	Infinispan
ConcurrentWeakKeyHashMap	An alternative weak-key ConcurrentMap which is similar to ConcurrentHashMap.	Class	org.infinispan.commons.util.concurrent	Infinispan
ConcurrentWeakKeyHashMap .ReusableIterator		Interface	org.infinispan.commons.util.concurrent.ConcurrentWeakKeyHashMap	Infinispan
FutureListener	A listener that is called back when a future is done.	Interface	org.infinispan.commons.util.concurrent	Infinispan
Futures	Utilities for NotifyingFuture composition.	Class	org.infinispan.commons.util.concurrent	Infinispan
NoOpFuture	A future that doesn't do anything and simply returns a given return value.	Class	org.infinispan.commons.util.concurrent	Infinispan
NotifyingFuture	A sub-interface of a Future, that allows for listeners to be attached so that observers can be notified of when the See FutureListener for more details.	Interface	org.infinispan.commons.util.concurrent	Infinispan
NotifyingFutureImpl	Constructs an instance of a NotifyingFuture.	Class	org.infinispan.commons.util.concurrent	Infinispan
NotifyingNotifiableFuture	An internal interface which adds the ability to inform the future of completion.	Interface	org.infinispan.commons.util.concurrent	Infinispan
ParallelIterableMap	Map implementing this interface provide a mechanism for parallel key/value iteration.	Interface	org.infinispan.commons.util.concurrent	Infinispan
ConcurrentMultiMap	An implementation of a ConcurrentMultiMap Adds/remove is serialized over the specified key	Class	akka.util	Akka
ConcurrentArrayQueue	A concurrent, unbounded implementation of Queue that uses singly-linked array blocks This class is a drop-in replacement for ConcurrentLinkedQueue, with similar performance	Class	org.eclipse.jetty.util	Jetty
ConcurrentArrayQueue .Block		Class	org.eclipse.jetty.util.ConcurrentArrayQueue	Jetty
ConcurrentHashSet		Class	org.eclipse.jetty.util	Jetty
ConcurrentHashIndex	A fast threadsafe index that supports constant-time lookup in both directions.	Class	edu.stanford.nlp.util.concurrent	Stanford Parser
InterruptibleMulticoreWrapper		Class	edu.stanford.nlp.util.concurrent	Stanford Parser
MulticoreWrapper	Provides convenient multicore processing for threadsafe objects.	Class	edu.stanford.nlp.util.concurrent	Stanford Parser
SynchronizedInterner	For interning (canonicalizing) things in a multi-threaded environment.	Class	edu.stanford.nlp.util.concurrent	Stanford Parser
ThreadsafeProcessor	Objects that wish to use MulticoreWrapper for multicore support must implement this interface.	Interface	edu.stanford.nlp.util.concurrent	Stanford Parser
AbstractCheckedFuture	A delegating wrapper around a ListenableFuture that adds support for the checkedGet() and checkedGet(long, TimeUnit) methods.	Class	com.google.common.util.concurrent	Google Guava
AbstractExecutionThreadService	Base class for services that can implement startUp(), run() and shutDown() methods.	Class	com.google.common.util.concurrent	Google Guava
AbstractFuture	An abstract implementation of the ListenableFuture interface.	Class	com.google.common.util.concurrent	Google Guava
AbstractIdleService	Base class for services that do not need a thread while running but may need one during startup and shutdown.	Class	com.google.common.util.concurrent	Google Guava
AbstractListeningExecutorService	Abstract ListeningExecutorService implementation that creates ListenableFutureTask instances for each Runnable and Callable submitted	Class	com.google.common.util.concurrent	Google Guava
AbstractScheduledService	Base class for services that can implement startUp() and shutDown() but while in the running state need to perform a periodic task.	Class	com.google.common.util.concurrent	Google Guava
AbstractScheduledService .CustomScheduler	A AbstractScheduledService.	Class	com.google.common.util.concurrent.AbstractScheduledService	Google Guava
AbstractScheduledService .CustomScheduler .Schedule	A value object that represents an absolute delay until a task should be invoked.	Class	com.google.common.util.concurrent.AbstractScheduledService.CustomScheduler	Google Guava
AbstractScheduledService .Scheduler	A scheduler defines the policy for how the AbstractScheduledService should run its Consider using the newFixedDelaySchedule(long, long, java.	Class	com.google.common.util.concurrent.AbstractScheduledService	Google Guava
AbstractService	Base class for implementing services that can handle doStart() and doStop() requests, responding to them with notifyStarted() and notifyStopped()	Class	com.google.common.util.concurrent	Google Guava
AsyncFunction	Transforms a value, possibly asynchronously.	Interface	com.google.common.util.concurrent	Google Guava
AtomicDouble	A double value that may be updated atomically.	Class	com.google.common.util.concurrent	Google Guava
AtomicDoubleArray	A double array in which elements may be updated atomically.	Class	com.google.common.util.concurrent	Google Guava
AtomicLongMap	A map containing long values that can be atomically updated.	Class	com.google.common.util.concurrent	Google Guava
Atomics	Static utility methods pertaining to classes in the java.	Class	com.google.common.util.concurrent	Google Guava
Callables	Static utility methods pertaining to the Callable interface.	Class	com.google.common.util.concurrent	Google Guava
CheckedFuture	A CheckedFuture is a ListenableFuture that includes versions of the get methods that can throw a checked exception.	Interface	com.google.common.util.concurrent	Google Guava
CycleDetectingLockFactory	The CycleDetectingLockFactory creates ReentrantLock instances and ReentrantReadWriteLock instances that detect potential deadlock by checking	Class	com.google.common.util.concurrent	Google Guava
CycleDetectingLockFactory .Policies	Pre-defined CycleDetectingLockFactory.	Class	com.google.common.util.concurrent.CycleDetectingLockFactory	Google Guava
CycleDetectingLockFactory .Policy	Encapsulates the action to be taken when a potential deadlock is encountered.	Interface	com.google.common.util.concurrent.CycleDetectingLockFactory	Google Guava
CycleDetectingLockFactory .PotentialDeadlockException	Represents a detected cycle in lock acquisition ordering.	Class	com.google.common.util.concurrent.CycleDetectingLockFactory	Google Guava
CycleDetectingLockFactory .WithExplicitOrdering	A CycleDetectingLockFactory.	Class	com.google.common.util.concurrent.CycleDetectingLockFactory	Google Guava
ExecutionError	Error variant of ExecutionException.	Class	com.google.common.util.concurrent	Google Guava
ExecutionList	A list of listeners, each with an associated Executor, that guarantees that every Runnable that is added will	Class	com.google.common.util.concurrent	Google Guava
FakeTimeLimiter	A TimeLimiter implementation which actually does not attempt to limit time at all.	Class	com.google.common.util.concurrent	Google Guava
ForwardingBlockingQueue	A BlockingQueue which forwards all its method calls to another BlockingQueue.	Class	com.google.common.util.concurrent	Google Guava
ForwardingCheckedFuture	A future which forwards all its method calls to another future.	Class	com.google.common.util.concurrent	Google Guava
ForwardingCheckedFuture .SimpleForwardingCheckedFuture	A simplified version of ForwardingCheckedFuture where subclasses can pass in an already constructed CheckedFuture as the delegate.	Class	com.google.common.util.concurrent.ForwardingCheckedFuture	Google Guava
ForwardingExecutorService	An executor service which forwards all its method calls to another executor service.	Class	com.google.common.util.concurrent	Google Guava
ForwardingFuture	A Future which forwards all its method calls to another future.	Class	com.google.common.util.concurrent	Google Guava
ForwardingFuture .SimpleForwardingFuture	A simplified version of ForwardingFuture where subclasses can pass in an already constructed Future as the delegate.	Class	com.google.common.util.concurrent.ForwardingFuture	Google Guava
ForwardingListenableFuture	A ListenableFuture which forwards all its method calls to another future.	Class	com.google.common.util.concurrent	Google Guava
ForwardingListenableFuture .SimpleForwardingListenableFuture	A simplified version of ForwardingListenableFuture where subclasses can pass in an already constructed ListenableFuture	Class	com.google.common.util.concurrent.ForwardingListenableFuture	Google Guava
ForwardingListeningExecutorService	A listening executor service which forwards all its method calls to another listening executor service.	Class	com.google.common.util.concurrent	Google Guava
FutureCallback	A callback for accepting the results of a Future computation asynchronously.	Interface	com.google.common.util.concurrent	Google Guava
FutureFallback	Provides a backup Future to replace an earlier failed Future.	Interface	com.google.common.util.concurrent	Google Guava
Futures	Static utility methods pertaining to the Future interface.	Class	com.google.common.util.concurrent	Google Guava
JdkFutureAdapters	Utilities necessary for working with libraries that supply plain Future instances.	Class	com.google.common.util.concurrent	Google Guava
ListenableFuture	A Future that accepts completion listeners.	Interface	com.google.common.util.concurrent	Google Guava
ListenableFutureTask	A FutureTask that also implements the ListenableFuture interface.	Class	com.google.common.util.concurrent	Google Guava
ListenableScheduledFuture	Helper interface to implement both ListenableFuture andSince:15.	Interface	com.google.common.util.concurrent	Google Guava
ListeningExecutorService	An ExecutorService that returns ListenableFuture instances.	Interface	com.google.common.util.concurrent	Google Guava
ListeningScheduledExecutorService	A ScheduledExecutorService that returns ListenableFuture instances from its ExecutorService methods.	Interface	com.google.common.util.concurrent	Google Guava
Monitor	A synchronization abstraction supporting waiting on arbitrary boolean conditions.	Class	com.google.common.util.concurrent	Google Guava
Monitor .Guard	A boolean condition for which a thread may wait.	Class	com.google.common.util.concurrent.Monitor	Google Guava
MoreExecutors	Factory and utility methods for Executor, ExecutorService, and ThreadFactory.	Class	com.google.common.util.concurrent	Google Guava
RateLimiter	A rate limiter.	Class	com.google.common.util.concurrent	Google Guava
Runnables	Static utility methods pertaining to the Runnable interface.	Class	com.google.common.util.concurrent	Google Guava
Service	An object with an operational state, plus asynchronous startAsync() and stopAsync() lifecycle methods to transition between states.	Interface	com.google.common.util.concurrent	Google Guava
Service .Listener	A listener for the various state changes that a Service goes through in its lifecycle.	Class	com.google.common.util.concurrent.Service	Google Guava
Service .State	The lifecycle states of a service.	Class	com.google.common.util.concurrent.Service	Google Guava
ServiceManager	A manager for monitoring and controlling a set of services.	Class	com.google.common.util.concurrent	Google Guava
ServiceManager .Listener	A listener for the aggregate state changes of the services that are under management.	Class	com.google.common.util.concurrent.ServiceManager	Google Guava
SettableFuture	A ListenableFuture whose result may be set by a set(Object) or setException(Throwable) call.	Class	com.google.common.util.concurrent	Google Guava
SimpleTimeLimiter	A TimeLimiter that runs method calls in the background using an ExecutorService.	Class	com.google.common.util.concurrent	Google Guava
Striped	A striped Lock/Semaphore/ReadWriteLock.	Class	com.google.common.util.concurrent	Google Guava
ThreadFactoryBuilder	A ThreadFactory builder, providing any combination of these features: whether threads should be marked as daemon	Class	com.google.common.util.concurrent	Google Guava
TimeLimiter	Produces proxies that impose a time limit on method calls to the proxied object.	Interface	com.google.common.util.concurrent	Google Guava
UncaughtExceptionHandlers	Factories for Thread.	Class	com.google.common.util.concurrent	Google Guava
UncheckedExecutionException	Unchecked variant of ExecutionException.	Class	com.google.common.util.concurrent	Google Guava
UncheckedTimeoutException	Unchecked version of TimeoutException.	Class	com.google.common.util.concurrent	Google Guava
Uninterruptibles	Utilities for treating interruptible operations as uninterruptible.	Class	com.google.common.util.concurrent	Google Guava
AbstractEventExecutor	Abstract base class for EventExecutor implementations.	Class	io.netty.util.concurrent	Netty
AbstractEventExecutorGroup	Abstract base class for EventExecutorGroup implementations.	Class	io.netty.util.concurrent	Netty
AbstractFuture	Abstract Future implementation which does not allow for cancellation.	Class	io.netty.util.concurrent	Netty
AbstractScheduledEventExecutor	Abstract base class for EventExecutors that want to support scheduling.	Class	io.netty.util.concurrent	Netty
BlockingOperationException	An IllegalStateException which is raised when a user performed a blocking operationwhen the user is in an event loop thread.	Class	io.netty.util.concurrent	Netty
CompleteFuture	A skeletal Future implementation which represents a Future which has been completed already.	Class	io.netty.util.concurrent	Netty
DefaultEventExecutor		Class	io.netty.util.concurrent	Netty
DefaultEventExecutorGroup	Default implementation of MultithreadEventExecutorGroup which will use DefaultEventExecutorinstances to handle the tasks.	Class	io.netty.util.concurrent	Netty
DefaultExecutorServiceFactory	An implementation of an ExecutorServiceFactory that creates a new ForkJoinPool on eachcall to newExecutorService(int).	Class	io.netty.util.concurrent	Netty
DefaultProgressivePromise		Class	io.netty.util.concurrent	Netty
DefaultPromise		Class	io.netty.util.concurrent	Netty
DefaultThreadFactory	A ThreadFactory implementation with a simple naming rule.	Class	io.netty.util.concurrent	Netty
EventExecutor	The EventExecutor is a special EventExecutorGroup which comeswith some handy methods to see if a Thread is executed in a event loop.	Interface	io.netty.util.concurrent	Netty
EventExecutorGroup	The EventExecutorGroup is responsible for providing the EventExecutor's to usevia its next() method.	Interface	io.netty.util.concurrent	Netty
ExecutorServiceFactory	An object that creates new ExecutorService on demand.	Interface	io.netty.util.concurrent	Netty
FailedFuture	The CompleteFuture which is failed already.	Class	io.netty.util.concurrent	Netty
FastThreadLocal	A special variant of ThreadLocal that yields higher access performance when accessed from aFastThreadLocalThread.	Class	io.netty.util.concurrent	Netty
FastThreadLocalAccess	Netty's Thread implementations implement this interface to provide fast access to FastThreadLocalSee Also:FastThreadLocalThread	Interface	io.netty.util.concurrent	Netty
FastThreadLocalThread	A special Thread that provides fast access to FastThreadLocal variables.	Class	io.netty.util.concurrent	Netty
Future	The result of an asynchronous operation.	Interface	io.netty.util.concurrent	Netty
FutureListener	A subtype of GenericFutureListener that hides type parameter for convenience.	Interface	io.netty.util.concurrent	Netty
GenericFutureListener	Listens to the result of a Future.	Interface	io.netty.util.concurrent	Netty
GenericProgressiveFutureListener		Interface	io.netty.util.concurrent	Netty
GlobalEventExecutor	Single-thread singleton EventExecutor.	Class	io.netty.util.concurrent	Netty
ImmediateEventExecutor	AbstractEventExecutor which execute tasks in the callers thread.	Class	io.netty.util.concurrent	Netty
ImmediateExecutor	Executor which execute tasks in the callers thread.	Class	io.netty.util.concurrent	Netty
MultithreadEventExecutorGroup		Class	io.netty.util.concurrent	Netty
PausableEventExecutor		Interface	io.netty.util.concurrent	Netty
ProgressiveFuture	A Future which is used to indicate the progress of an operation.	Interface	io.netty.util.concurrent	Netty
ProgressivePromise	Special ProgressiveFuture which is writable.	Interface	io.netty.util.concurrent	Netty
Promise	Special Future which is writable.	Interface	io.netty.util.concurrent	Netty
PromiseAggregator	GenericFutureListener implementation which consolidates multiple Futuresinto one, by listening to individual Futures and producing an aggregated result	Class	io.netty.util.concurrent	Netty
PromiseNotifier	GenericFutureListener implementation which takes other Futuresand notifies them on completion.	Class	io.netty.util.concurrent	Netty
ScheduledFuture	The result of an scheduled asynchronous operation.	Interface	io.netty.util.concurrent	Netty
SingleThreadEventExecutor	Abstract base class for EventExecutor's that execute all its submitted tasks in a single thread.	Class	io.netty.util.concurrent	Netty
SucceededFuture	The CompleteFuture which is succeeded already.	Class	io.netty.util.concurrent	Netty
ThreadPerTaskExecutor		Class	io.netty.util.concurrent	Netty
WrappedEventExecutor	A marker interface indicating that the EventExecutor is a wrapper aroundanother EventExecutor implementation.	Interface	io.netty.util.concurrent	Netty
AbortException	Thrown when a task is aborted.	Class	org.apache.pivot.util.concurrent	Apache Pivot
Task	Abstract base class for tasks.	Class	org.apache.pivot.util.concurrent	Apache Pivot
TaskExecutionException	Thrown when an error occurs during task execution.	Class	org.apache.pivot.util.concurrent	Apache Pivot
TaskGroup	Task that runs a group of tasks in parallel and notifies listeners when all tasks are complete.	Class	org.apache.pivot.util.concurrent	Apache Pivot
TaskListener	Task listener interface.	Interface	org.apache.pivot.util.concurrent	Apache Pivot
TaskSequence	Task that runs a sequence of tasks in series and notifies listeners when all tasks are complete.	Class	org.apache.pivot.util.concurrent	Apache Pivot
TimeoutException	Thrown when an executing task has timed out.	Class	org.apache.pivot.util.concurrent	Apache Pivot
ConcurrentHashSet	S e e A l s o : S e r i a l i z e d F o r m C o n s t r u c t o r S u m m a r y C o n c u r r e n t H a s h S e t ( )	Class	com.liferay.portal.kernel.util	Liferay Portal
ConcurrentCache	The ConcurrentCache interface is used to represent a cache that will store key value pairs.	Class	org.simpleframework.xml.util	Simple
AsyncConditions	Alternative to class BlockingVariable(s) that allows to evaluate conditions in a thread other than the spec runner's thread(s).	Class	spock.util.concurrent	Spock
BlockingVariable	A statically typed variable whose get() method will block until some other thread has set a value with the set() method, or a timeout expires.	Class	spock.util.concurrent	Spock
PollingConditions	Repeatedly evaluates one or more conditions until they are satisfied or a timeout has elapsed.	Class	spock.util.concurrent	Spock
ConcurrentHashIndex	A fast threadsafe index that supports constant-time lookup in both directions.	Class	edu.stanford.nlp.util.concurrent	JavaNlp
InterruptibleMulticoreWrapper		Class	edu.stanford.nlp.util.concurrent	JavaNlp
MulticoreWrapper	Provides convenient multicore processing for threadsafe objects.	Class	edu.stanford.nlp.util.concurrent	JavaNlp
SynchronizedInterner	For interning (canonicalizing) things in a multi-threaded environment.	Class	edu.stanford.nlp.util.concurrent	JavaNlp
ThreadsafeProcessor	Objects that wish to use MulticoreWrapper for multicore support must implement this interface.	Interface	edu.stanford.nlp.util.concurrent	JavaNlp
ConcurrentModificationException	An ConcurrentModificationException is thrown when a Collection is modified and an existing iterator on the Collection is used to modify the	Class	java.util	CodeName One
ConcurrentHashSet	This class implements the Set interface, backed by a ConcurrentHashMap instance.	Class	org.jivesoftware.util	OpenFire
AbstractHaltableProcess	Abstract base class for tasks whose processing may be halted asynchronously.	Class	com.bigdata.util.concurrent	BlazeGraph
BufferedConcurrentHashMap	A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.	Class	org.infinispan.util.concurrent	BlazeGraph
BufferedConcurrentHashMap .Eviction		Class	org.infinispan.util.concurrent	BlazeGraph
BufferedConcurrentHashMap .EvictionListener		Interface	org.infinispan.util.concurrent	BlazeGraph
CanonicalFactory	A pattern for a canonicalizing factory based on a map with weak values.	Class	com.bigdata.util.concurrent	BlazeGraph
Computable	Something which computes one value from another.	Interface	com.bigdata.util.concurrent	BlazeGraph
DeltaMovingAverageTask	Moving average based on the change in some sampled value.	Class	com.bigdata.util.concurrent	BlazeGraph
ExecutionExceptions	Class enumerates all exceptions thrown for a set of tasks.	Class	com.bigdata.util.concurrent	BlazeGraph
ExecutionHelper	Helper class for managing the execution of a set of Callable tasks on an ExecutorService.	Class	com.bigdata.util.concurrent	BlazeGraph
Haltable	Abstract base class for tasks whose processing may be halted asynchronously.	Class	com.bigdata.util.concurrent	BlazeGraph
IHaltable	Interface extends Future and provides an interface for managing the termination of a process from within that process.	Interface	com.bigdata.util.concurrent	BlazeGraph
IQueueCounters	Interface defines and documents the names and meanings of counters pertaining to blocking queues (of tasks) and services executing tasks and includes	Interface	com.bigdata.util.concurrent	BlazeGraph
IQueueCounters .ITaskCounters	Counters defined by TaskCounters.	Interface	com.bigdata.util.concurrent	BlazeGraph
IQueueCounters .IThreadPoolExecutorCounters	Additional counters available for any ThreadPoolExecutor.	Interface	com.bigdata.util.concurrent	BlazeGraph
IQueueCounters .IThreadPoolExecutorTaskCounters	Additional counters available for any ThreadPoolExecutor which is processing AbstractTasks.	Interface	com.bigdata.util.concurrent	BlazeGraph
IQueueCounters .IWriteServiceExecutorCounters	Additional counters available for the WriteServiceExecutor.	Interface	com.bigdata.util.concurrent	BlazeGraph
Latch	A synchronization aid that allows one or more threads to await a counter becoming zero.	Class	com.bigdata.util.concurrent	BlazeGraph
LatchedExecutor	A fly weight helper class that runs tasks either sequentially or with limited parallelism against some thread pool.	Class	com.bigdata.util.concurrent	BlazeGraph
MappedTaskExecutor	A fly weight helper class that runs tasks either sequentially or with limited parallelism against some thread pool.	Class	com.bigdata.util.concurrent	BlazeGraph
Memoizer	Pattern using a FutureTask to force synchronization only on tasks waiting for the same computation.	Class	com.bigdata.util.concurrent	BlazeGraph
MonitoredFutureTask	Helper task for monitoring the results of otherwise unwatched tasks.	Class	com.bigdata.util.concurrent	BlazeGraph
MovingAverageTask	Class tracks a the moving average of some sampled datum.	Class	com.bigdata.util.concurrent	BlazeGraph
QueueSizeMovingAverageTask	Class tracks the moving average of the queue size.	Class	com.bigdata.util.concurrent	BlazeGraph
ShutdownHelper	Helper class for normal shutdown of an ExecutorService.	Class	com.bigdata.util.concurrent	BlazeGraph
TaskCounters	Class captures various data about the execution of AbstractTasks.	Class	com.bigdata.util.concurrent	BlazeGraph
TestAll	Aggregates test suites in increasing dependency order.	Class	com.bigdata.util.concurrent	BlazeGraph
TestHaltable	Test suite for Haltable.	Class	com.bigdata.util.concurrent	BlazeGraph
TestLatch	Unit tests for Latch.	Class	com.bigdata.util.concurrent	BlazeGraph
ThreadGuard	Pattern used to guard critical regions that await Conditions when a concurrent event may cause the Condition to become unsatisfiable.	Class	com.bigdata.util.concurrent	BlazeGraph
ThreadGuard .Guard		Class	com.bigdata.util.concurrent	BlazeGraph
ThreadPoolExecutorBaseStatisticsTask	Class tracks a variety of information about a ThreadPoolExecutor including the moving average of its queue length, queue size, average active	Class	com.bigdata.util.concurrent	BlazeGraph
ThreadPoolExecutorStatisticsTask	Class tracks a variety of information about a ThreadPoolExecutor including the moving average of its queue length, queuing times, etc.	Class	com.bigdata.util.concurrent	BlazeGraph
WriteTaskCounters		Class	com.bigdata.util.concurrent	BlazeGraph
CallableFromRunnable	Wraps a Runnable as a Callable.	Class	brooklyn.util.concurrent	Brooklyn
ConcurrentUpdateHandler	Handles a a series of updates or events to handle as one.	Class	lnb.util	LNB
ConcurrentLog	jdk-based logger tend to block at java.	Class	net.yacy.cora.util	Yacy
ConcurrentLog .Message		Class	net.yacy.cora.util	Yacy
ConcurrentLog .Worker		Class	net.yacy.cora.util	Yacy

Search Java Classes and Packages