# Uses of Package
java.util.concurrent

Packages that use java.util.concurrent
Package | Description
--- | ---
com.sun.net.httpserver | Provides a simple high-level Http server API, which can be used to build embedded HTTP servers.
com.sun.source.util | Provides utilities for operations on abstract syntax trees (AST).
java.lang | Provides classes that are fundamental to the design of the Java programming language.
java.lang.ref | Provides reference-object classes, which support a limited degree of interaction with the garbage collector.
java.net.http | HTTP Client and WebSocket APIs
java.nio.channels | Defines channels, which represent connections to entities that are capable of performing I/O operations, such as files and sockets; defines selectors, for multiplexed, non-blocking I/O operations.
java.nio.channels.spi | Service-provider classes for the `java.nio.channels` package.
java.nio.file | Defines interfaces and classes for the Java virtual machine to access files, file attributes, and file systems.
java.nio.file.attribute | Interfaces and classes providing access to file and file system attributes.
java.nio.file.spi | Service-provider classes for the `java.nio.file` package.
java.sql | Provides the API for accessing and processing data stored in a data source (usually a relational database) using the Java™ programming language.
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.
javax.management | Provides the core classes for the Java Management Extensions.
javax.swing | Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.
javax.tools | Provides interfaces for tools which can be invoked from a program, for example, compilers.

Classes in java.util.concurrent used by com.sun.net.httpserver
Class | Description
--- | ---
Executor | An object that executes submitted `Runnable` tasks.

Classes in java.util.concurrent used by com.sun.source.util
Class | Description
--- | ---
Callable | A task that returns a result and may throw an exception.

Classes in java.util.concurrent used by java.lang
Class | Description
--- | ---
CompletableFuture | A `Future` that may be explicitly completed (setting its value and status), and may be used as a `CompletionStage`, supporting dependent functions and actions that trigger upon its completion.
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.lang.ref
Class | Description
--- | ---
ThreadFactory | An object that creates new threads on demand.

Classes in java.util.concurrent used by java.net.http
Class | Description
--- | ---
CompletableFuture | A `Future` that may be explicitly completed (setting its value and status), and may be used as a `CompletionStage`, supporting dependent functions and actions that trigger upon its completion.
CompletionStage | A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
ConcurrentMap | A `Map` providing thread safety and atomicity guarantees.
Executor | An object that executes submitted `Runnable` tasks.
Flow.Publisher | A producer of items (and related control messages) received by Subscribers.
Flow.Subscriber | A receiver of messages.

Classes in java.util.concurrent used by java.nio.channels
Class | Description
--- | ---
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.
Future | A `Future` represents the result of an asynchronous computation.
ThreadFactory | An object that creates new threads on demand.
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.nio.channels.spi
Class | Description
--- | ---
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.
ThreadFactory | An object that creates new threads on demand.

Classes in java.util.concurrent used by java.nio.file
Class | 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.nio.file.attribute
Class | 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.nio.file.spi
Class | Description
--- | ---
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.

Classes in java.util.concurrent used by java.sql
Class | Description
--- | ---
Executor | An object that executes submitted `Runnable` tasks.

Classes in java.util.concurrent used by java.util.concurrent
Class | 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.
CompletableFuture | A `Future` that may be explicitly completed (setting its value and status), and may be used as a `CompletionStage`, supporting dependent functions and actions that trigger upon its completion.
CompletionService | A service that decouples the production of new asynchronous tasks from the consumption of the results of completed tasks.
CompletionStage | A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes.
ConcurrentHashMap.KeySetView | A view of a ConcurrentHashMap as a `Set` of keys, in which additions may optionally be enabled by mapping to a common value.
ConcurrentMap | A `Map` providing thread safety and atomicity guarantees.
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.
Flow.Publisher | A producer of items (and related control messages) received by Subscribers.
Flow.Subscriber | A receiver of messages.
Flow.Subscription | Message control linking a `Flow.Publisher` and `Flow.Subscriber`.
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 | 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 | Description
--- | ---
ConcurrentMap | A `Map` providing thread safety and atomicity guarantees.

Classes in java.util.concurrent used by javax.management
Class | Description
--- | ---
Executor | An object that executes submitted `Runnable` tasks.

Classes in java.util.concurrent used by javax.swing
Class | Description
--- | ---
ExecutionException | Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
Future | A `Future` represents the result of an asynchronous computation.
RunnableFuture | A `Future` that is `Runnable`.
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.

Classes in java.util.concurrent used by javax.tools
Class | Description
--- | ---
Callable | A task that returns a result and may throw an exception.