#Java.util.concurrent Classes and Interfaces

_{#Java.util.concurrent Classes and Interfaces - 102 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
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

Search Java Classes and Packages