# 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.