# Uses of Package
java.util.concurrent

- Packages that use java.util.concurrent
  Package | Description
  --- | ---
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  java.util.concurrent.locks | Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
  java.util.stream | Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
  org.openide.util.lookup | Support classes for the Registration and `Lookup` extension mechanism.

- Classes in java.util.concurrent used by java.util.concurrent
  Class and Description
  AbstractExecutorService Provides default implementations of `ExecutorService` execution methods.
  BlockingDeque A `Deque` 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 A `Queue` 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.
  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.
  Callable A task that returns a result and may throw an exception.
  CompletionService A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
  ConcurrentMap A `Map` providing additional atomic `putIfAbsent`, `remove`, and `replace` methods.
  ConcurrentNavigableMap A `ConcurrentMap` supporting `NavigableMap` operations, and recursively so for its navigable sub-maps.
  ConcurrentSkipListMap A scalable concurrent `ConcurrentNavigableMap` implementation.
  ConcurrentSkipListSet A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
  CountedCompleter A `ForkJoinTask` with a completion action performed when triggered and there are no remaining pending actions.
  Delayed A mix-in style interface for marking objects that should be acted upon after a given delay.
  ExecutionException Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
  Executor An object that executes submitted `Runnable` tasks.
  ExecutorService An `Executor` that provides methods to manage termination and methods that can produce a `Future` for tracking progress of one or more asynchronous tasks.
  ForkJoinPool An `ExecutorService` for running `ForkJoinTask`s.
  ForkJoinPool.ForkJoinWorkerThreadFactory Factory for creating new `ForkJoinWorkerThread`s.
  ForkJoinPool.ManagedBlocker Interface for extending managed parallelism for tasks running in `ForkJoinPool`s.
  ForkJoinTask Abstract base class for tasks that run within a `ForkJoinPool`.
  ForkJoinWorkerThread A thread managed by a `ForkJoinPool`, which executes `ForkJoinTask`s.
  Future A `Future` represents the result of an asynchronous computation.
  Phaser A reusable synchronization barrier, similar in functionality to `CyclicBarrier` and `CountDownLatch` but supporting more flexible usage.
  RejectedExecutionHandler A handler for tasks that cannot be executed by a `ThreadPoolExecutor`.
  RunnableFuture A `Future` that is `Runnable`.
  RunnableScheduledFuture A `ScheduledFuture` that is `Runnable`.
  ScheduledExecutorService An `ExecutorService` that can schedule commands to run after a given delay, or to execute periodically.
  ScheduledFuture A delayed result-bearing action that can be cancelled.
  ThreadFactory An object that creates new threads on demand.
  ThreadLocalRandom A random number generator isolated to the current thread.
  ThreadPoolExecutor An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.
  TimeoutException Exception thrown when a blocking operation times out.
  TimeUnit A `TimeUnit` 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.
  TransferQueue A `BlockingQueue` in which producers may wait for consumers to receive elements.

- Classes in java.util.concurrent used by java.util.concurrent.locks
  Class and Description
  TimeUnit A `TimeUnit` 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.

- Classes in java.util.concurrent used by java.util.stream
  Class and Description
  ConcurrentMap A `Map` providing additional atomic `putIfAbsent`, `remove`, and `replace` methods.

- Classes in java.util.concurrent used by org.openide.util.lookup
  Class and Description
  Executor An object that executes submitted `Runnable` tasks.

Copyright © 2025 API Design. All Rights Reserved.