# java.util.concurrent # java.util.concurrent ## Interfaces |------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [BlockingDeque](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingDeque) | A[Deque](https://developer.android.com/reference/kotlin/java/util/Deque.html#)that additionally supports blocking operations that wait for the deque to become non-empty when retrieving an element, and wait for space to become available in the deque when storing an element. | | [BlockingQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue) | A[Queue](https://developer.android.com/reference/kotlin/java/util/Queue.html#)that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element. | | [Callable](https://developer.android.com/reference/kotlin/java/util/concurrent/Callable) | A task that returns a result and may throw an exception. | | [AsynchronousCompletionTask](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletableFuture.AsynchronousCompletionTask) | A marker interface identifying asynchronous tasks produced by`async`methods. | | [CompletionService](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletionService) | A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks. | | [CompletionStage](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletionStage) | A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes. | | [ConcurrentMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentMap) | A[Map](https://developer.android.com/reference/kotlin/java/util/Map.html#)providing thread safety and atomicity guarantees. | | [ConcurrentNavigableMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentNavigableMap) | A[ConcurrentMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentMap)supporting[NavigableMap](https://developer.android.com/reference/kotlin/java/util/NavigableMap.html#)operations, and recursively so for its navigable sub-maps. | | [Delayed](https://developer.android.com/reference/kotlin/java/util/concurrent/Delayed) | A mix-in style interface for marking objects that should be acted upon after a given delay. | | [Executor](https://developer.android.com/reference/kotlin/java/util/concurrent/Executor) | An object that executes submitted[Runnable](https://developer.android.com/reference/kotlin/java/lang/Runnable.html#)tasks. | | [ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService) | An[Executor](https://developer.android.com/reference/kotlin/java/util/concurrent/Executor)that provides methods to manage termination and methods that can produce a[Future](https://developer.android.com/reference/kotlin/java/util/concurrent/Future)for tracking progress of one or more asynchronous tasks. | | [Processor](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Processor) | A component that acts as both a Subscriber and Publisher. | | [Publisher](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Publisher) | A producer of items (and related control messages) received by Subscribers. | | [Subscriber](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Subscriber) | A receiver of messages. | | [Subscription](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Subscription) | Message control linking a[Publisher](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Publisher)and[Subscriber](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Subscriber). | | [ForkJoinWorkerThreadFactory](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool.ForkJoinWorkerThreadFactory) | Factory for creating new[ForkJoinWorkerThread](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinWorkerThread)s. | | [ManagedBlocker](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool.ManagedBlocker) | Interface for extending managed parallelism for tasks running in[ForkJoinPool](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool)s. | | [Future](https://developer.android.com/reference/kotlin/java/util/concurrent/Future) | A represents the result of an asynchronous computation. | | [RejectedExecutionHandler](https://developer.android.com/reference/kotlin/java/util/concurrent/RejectedExecutionHandler) | A handler for tasks that cannot be executed by a[ThreadPoolExecutor](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadPoolExecutor). | | [RunnableFuture](https://developer.android.com/reference/kotlin/java/util/concurrent/RunnableFuture) | A[Future](https://developer.android.com/reference/kotlin/java/util/concurrent/Future)that is[Runnable](https://developer.android.com/reference/kotlin/java/lang/Runnable.html#). | | [RunnableScheduledFuture](https://developer.android.com/reference/kotlin/java/util/concurrent/RunnableScheduledFuture) | A[ScheduledFuture](https://developer.android.com/reference/kotlin/java/util/concurrent/ScheduledFuture)that is[Runnable](https://developer.android.com/reference/kotlin/java/lang/Runnable.html#). | | [ScheduledExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ScheduledExecutorService) | An[ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService)that can schedule commands to run after a given delay, or to execute periodically. | | [ScheduledFuture](https://developer.android.com/reference/kotlin/java/util/concurrent/ScheduledFuture) | A delayed result-bearing action that can be cancelled. | | [ThreadFactory](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadFactory) | An object that creates new threads on demand. | | [TransferQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/TransferQueue) | A[BlockingQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)in which producers may wait for consumers to receive elements. | ## Classes |--------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [AbstractExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/AbstractExecutorService) | Provides default implementations of[ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService)execution methods. | | [ArrayBlockingQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/ArrayBlockingQueue) | A bounded[blocking queue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)backed by an array. | | [CompletableFuture](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletableFuture) | A[Future](https://developer.android.com/reference/kotlin/java/util/concurrent/Future)that may be explicitly completed (setting its value and status), and may be used as a[CompletionStage](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletionStage), supporting dependent functions and actions that trigger upon its completion. | | [ConcurrentHashMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentHashMap) | A hash table supporting full concurrency of retrievals and high expected concurrency for updates. | | [ConcurrentLinkedDeque](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentLinkedDeque) | An unbounded concurrent[deque](https://developer.android.com/reference/kotlin/java/util/Deque.html#)based on linked nodes. | | [ConcurrentLinkedQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentLinkedQueue) | An unbounded thread-safe[queue](https://developer.android.com/reference/kotlin/java/util/Queue.html#)based on linked nodes. | | [ConcurrentSkipListMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentSkipListMap) | A scalable concurrent[ConcurrentNavigableMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentNavigableMap)implementation. | | [ConcurrentSkipListSet](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentSkipListSet) | A scalable concurrent[NavigableSet](https://developer.android.com/reference/kotlin/java/util/NavigableSet.html#)implementation based on a[ConcurrentSkipListMap](https://developer.android.com/reference/kotlin/java/util/concurrent/ConcurrentSkipListMap). | | [CopyOnWriteArrayList](https://developer.android.com/reference/kotlin/java/util/concurrent/CopyOnWriteArrayList) | A thread-safe variant of[java.util.ArrayList](https://developer.android.com/reference/kotlin/java/util/ArrayList.html#)in which all mutative operations (`add`,`set`, and so on) are implemented by making a fresh copy of the underlying array. | | [CopyOnWriteArraySet](https://developer.android.com/reference/kotlin/java/util/concurrent/CopyOnWriteArraySet) | A[Set](https://developer.android.com/reference/kotlin/java/util/Set.html#)that uses an internal[CopyOnWriteArrayList](https://developer.android.com/reference/kotlin/java/util/concurrent/CopyOnWriteArrayList)for all of its operations. | | [CountDownLatch](https://developer.android.com/reference/kotlin/java/util/concurrent/CountDownLatch) | A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes. | | [CountedCompleter](https://developer.android.com/reference/kotlin/java/util/concurrent/CountedCompleter) | A[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask)with a completion action performed when triggered and there are no remaining pending actions. | | [CyclicBarrier](https://developer.android.com/reference/kotlin/java/util/concurrent/CyclicBarrier) | A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. | | [DelayQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/DelayQueue) | An unbounded[blocking queue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)of[Delayed](https://developer.android.com/reference/kotlin/java/util/concurrent/Delayed)elements, in which an element generally becomes eligible for removal when its delay has expired. | | [Exchanger](https://developer.android.com/reference/kotlin/java/util/concurrent/Exchanger) | A synchronization point at which threads can pair and swap elements within pairs. | | [ExecutorCompletionService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorCompletionService) | A[CompletionService](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletionService)that uses a supplied[Executor](https://developer.android.com/reference/kotlin/java/util/concurrent/Executor)to execute tasks. | | [Executors](https://developer.android.com/reference/kotlin/java/util/concurrent/Executors) | Factory and utility methods for[Executor](https://developer.android.com/reference/kotlin/java/util/concurrent/Executor),[ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService),[ScheduledExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ScheduledExecutorService),[ThreadFactory](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadFactory), and[Callable](https://developer.android.com/reference/kotlin/java/util/concurrent/Callable)classes defined in this package. | | [Flow](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow) | Interrelated interfaces and static methods for establishing flow-controlled components in which[Publishers](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Publisher)produce items consumed by one or more[Subscribers](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Subscriber), each managed by a[Subscription](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Subscription). | | [ForkJoinPool](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool) | An[ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService)for running[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask)s. | | [ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask) | Abstract base class for tasks that run within a[ForkJoinPool](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool). | | [ForkJoinWorkerThread](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinWorkerThread) | A thread managed by a[ForkJoinPool](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinPool), which executes[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask)s. | | [FutureTask](https://developer.android.com/reference/kotlin/java/util/concurrent/FutureTask) | A cancellable asynchronous computation. | | [LinkedBlockingDeque](https://developer.android.com/reference/kotlin/java/util/concurrent/LinkedBlockingDeque) | An optionally-bounded[blocking deque](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingDeque)based on linked nodes. | | [LinkedBlockingQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/LinkedBlockingQueue) | An optionally-bounded[blocking queue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)based on linked nodes. | | [LinkedTransferQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/LinkedTransferQueue) | An unbounded[TransferQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/TransferQueue)based on linked nodes. | | [Phaser](https://developer.android.com/reference/kotlin/java/util/concurrent/Phaser) | A reusable synchronization barrier, similar in functionality to[CyclicBarrier](https://developer.android.com/reference/kotlin/java/util/concurrent/CyclicBarrier)and[CountDownLatch](https://developer.android.com/reference/kotlin/java/util/concurrent/CountDownLatch)but supporting more flexible usage. | | [PriorityBlockingQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/PriorityBlockingQueue) | An unbounded[blocking queue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)that uses the same ordering rules as class[PriorityQueue](https://developer.android.com/reference/kotlin/java/util/PriorityQueue.html#)and supplies blocking retrieval operations. | | [RecursiveAction](https://developer.android.com/reference/kotlin/java/util/concurrent/RecursiveAction) | A recursive resultless[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask). | | [RecursiveTask](https://developer.android.com/reference/kotlin/java/util/concurrent/RecursiveTask) | A recursive result-bearing[ForkJoinTask](https://developer.android.com/reference/kotlin/java/util/concurrent/ForkJoinTask). | | [ScheduledThreadPoolExecutor](https://developer.android.com/reference/kotlin/java/util/concurrent/ScheduledThreadPoolExecutor) | A[ThreadPoolExecutor](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadPoolExecutor)that can additionally schedule commands to run after a given delay, or to execute periodically. | | [Semaphore](https://developer.android.com/reference/kotlin/java/util/concurrent/Semaphore) | A counting semaphore. | | [SubmissionPublisher](https://developer.android.com/reference/kotlin/java/util/concurrent/SubmissionPublisher) | A[Flow.Publisher](https://developer.android.com/reference/kotlin/java/util/concurrent/Flow.Publisher)that asynchronously issues submitted (non-null) items to current subscribers until it is closed. | | [SynchronousQueue](https://developer.android.com/reference/kotlin/java/util/concurrent/SynchronousQueue) | A[blocking queue](https://developer.android.com/reference/kotlin/java/util/concurrent/BlockingQueue)in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa. | | [ThreadLocalRandom](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadLocalRandom) | A random number generator (with period 264) isolated to the current thread. | | [ThreadPoolExecutor](https://developer.android.com/reference/kotlin/java/util/concurrent/ThreadPoolExecutor) | An[ExecutorService](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutorService)that executes each submitted task using one of possibly several pooled threads, normally configured using[Executors](https://developer.android.com/reference/kotlin/java/util/concurrent/Executors)factory methods. | ## Exceptions |------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [BrokenBarrierException](https://developer.android.com/reference/kotlin/java/util/concurrent/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 is waiting. | | [CancellationException](https://developer.android.com/reference/kotlin/java/util/concurrent/CancellationException) | Exception indicating that the result of a value-producing task, such as a[FutureTask](https://developer.android.com/reference/kotlin/java/util/concurrent/FutureTask), cannot be retrieved because the task was cancelled. | | [CompletionException](https://developer.android.com/reference/kotlin/java/util/concurrent/CompletionException) | Exception thrown when an error or other exception is encountered in the course of completing a result or task. | | [ExecutionException](https://developer.android.com/reference/kotlin/java/util/concurrent/ExecutionException) | Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception. | | [RejectedExecutionException](https://developer.android.com/reference/kotlin/java/util/concurrent/RejectedExecutionException) | Exception thrown by an[Executor](https://developer.android.com/reference/kotlin/java/util/concurrent/Executor)when a task cannot be accepted for execution. | | [TimeoutException](https://developer.android.com/reference/kotlin/java/util/concurrent/TimeoutException) | Exception thrown when a blocking operation times out. | ## Enums |------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [TimeUnit](https://developer.android.com/reference/kotlin/java/util/concurrent/TimeUnit) | A represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units. |