com.google.common.util.concurrent (Guava: Google Core Libraries for Java 28.1-jre API)

Interface Summary
Interface	Description
AsyncCallable<V>	Computes a value, possibly asynchronously.
AsyncFunction<I,O>	Transforms a value, possibly asynchronously.
CycleDetectingLockFactory.Policy	Encapsulates the action to be taken when a potential deadlock is encountered.
FutureCallback<V>	A callback for accepting the results of a `Future` computation asynchronously.
ListenableFuture<V>	A `Future` that accepts completion listeners.
ListenableScheduledFuture<V>	Helper interface to implement both `ListenableFuture` and `ScheduledFuture`.
ListeningExecutorService	An `ExecutorService` that returns `ListenableFuture` instances.
ListeningScheduledExecutorService	A `ScheduledExecutorService` that returns `ListenableFuture` instances from its `ExecutorService` methods.
Service	An object with an operational state, plus asynchronous `Service.startAsync()` and `Service.stopAsync()` lifecycle methods to transition between states.
TimeLimiter	Imposes a time limit on method calls.

Class Summary
Class	Description
AbstractExecutionThreadService	Base class for services that can implement `AbstractExecutionThreadService.startUp()`, `AbstractExecutionThreadService.run()` and `AbstractExecutionThreadService.shutDown()` methods.
AbstractFuture<V>	An abstract implementation of `ListenableFuture`, intended for advanced users only.
AbstractIdleService	Base class for services that do not need a thread while "running" but may need one during startup and shutdown.
AbstractListeningExecutorService	Abstract `ListeningExecutorService` implementation that creates `ListenableFuture` instances for each `Runnable` and `Callable` submitted to it.
AbstractScheduledService	Base class for services that can implement `AbstractScheduledService.startUp()` and `AbstractScheduledService.shutDown()` but while in the "running" state need to perform a periodic task.
AbstractScheduledService.CustomScheduler	A `AbstractScheduledService.Scheduler` that provides a convenient way for the `AbstractScheduledService` to use a dynamically changing schedule.
AbstractScheduledService.CustomScheduler.Schedule	A value object that represents an absolute delay until a task should be invoked.
AbstractScheduledService.Scheduler	A scheduler defines the policy for how the `AbstractScheduledService` should run its task.
AbstractService	Base class for implementing services that can handle `AbstractService.doStart()` and `AbstractService.doStop()` requests, responding to them with `AbstractService.notifyStarted()` and `AbstractService.notifyStopped()` callbacks.
AtomicDouble	A `double` value that may be updated atomically.
AtomicDoubleArray	A `double` array in which elements may be updated atomically.
AtomicLongMap<K>	A map containing `long` values that can be atomically updated.
Atomics	Static utility methods pertaining to classes in the `java.util.concurrent.atomic` package.
Callables	Static utility methods pertaining to the `Callable` interface.
CycleDetectingLockFactory	The `CycleDetectingLockFactory` creates `ReentrantLock` instances and `ReentrantReadWriteLock` instances that detect potential deadlock by checking for cycles in lock acquisition order.
CycleDetectingLockFactory.WithExplicitOrdering<E extends Enum<E>>	A `CycleDetectingLockFactory.WithExplicitOrdering` provides the additional enforcement of an application-specified ordering of lock acquisitions.
ExecutionList	A support class for `ListenableFuture` implementations to manage their listeners.
ExecutionSequencer	Serializes execution of a set of operations.
FakeTimeLimiter	A TimeLimiter implementation which actually does not attempt to limit time at all.
FluentFuture<V>	A `ListenableFuture` that supports fluent chains of operations.
ForwardingBlockingDeque<E>	A `BlockingDeque` which forwards all its method calls to another `BlockingDeque`.
ForwardingBlockingQueue<E>	A `BlockingQueue` which forwards all its method calls to another `BlockingQueue`.
ForwardingExecutorService	An executor service which forwards all its method calls to another executor service.
ForwardingFuture<V>	A `Future` which forwards all its method calls to another future.
ForwardingFuture.SimpleForwardingFuture<V>	A simplified version of `ForwardingFuture` where subclasses can pass in an already constructed `Future` as the delegate.
ForwardingListenableFuture<V>	A `ListenableFuture` which forwards all its method calls to another future.
ForwardingListenableFuture.SimpleForwardingListenableFuture<V>	A simplified version of `ForwardingListenableFuture` where subclasses can pass in an already constructed `ListenableFuture` as the delegate.
ForwardingListeningExecutorService	A listening executor service which forwards all its method calls to another listening executor service.
Futures	Static utility methods pertaining to the `Future` interface.
Futures.FutureCombiner<V>	A helper to create a new `ListenableFuture` whose result is generated from a combination of input futures.
JdkFutureAdapters	Utilities necessary for working with libraries that supply plain `Future` instances.
ListenableFutureTask<V>	A `FutureTask` that also implements the `ListenableFuture` interface.
Monitor	A synchronization abstraction supporting waiting on arbitrary boolean conditions.
Monitor.Guard	A boolean condition for which a thread may wait.
MoreExecutors	Factory and utility methods for `Executor`, `ExecutorService`, and `ThreadFactory`.
RateLimiter	A rate limiter.
Runnables	Static utility methods pertaining to the `Runnable` interface.
Service.Listener	A listener for the various state changes that a `Service` goes through in its lifecycle.
ServiceManager	A manager for monitoring and controlling a set of services.
ServiceManager.Listener	A listener for the aggregate state changes of the services that are under management.
SettableFuture<V>	A `ListenableFuture` whose result can be set by a `SettableFuture.set(Object)`, `SettableFuture.setException(Throwable)` or `SettableFuture.setFuture(ListenableFuture)` call.
SimpleTimeLimiter	A TimeLimiter that runs method calls in the background using an `ExecutorService`.
Striped<L>	A striped `Lock/Semaphore/ReadWriteLock`.
ThreadFactoryBuilder	A ThreadFactory builder, providing any combination of these features: whether threads should be marked as daemon threads a naming format a thread priority an uncaught exception handler a backing thread factory
UncaughtExceptionHandlers	Factories for `Thread.UncaughtExceptionHandler` instances.
Uninterruptibles	Utilities for treating interruptible operations as uninterruptible.

Enum Summary
Enum Description

CycleDetectingLockFactory.Policies
Pre-defined CycleDetectingLockFactory.Policy implementations.

Service.State
The lifecycle states of a service.

Enum Summary
Enum	Description
CycleDetectingLockFactory.Policies	Pre-defined `CycleDetectingLockFactory.Policy` implementations.
Service.State	The lifecycle states of a service.

Exception Summary
Exception	Description
CycleDetectingLockFactory.PotentialDeadlockException	Represents a detected cycle in lock acquisition ordering.
UncheckedExecutionException	Unchecked variant of `ExecutionException`.
UncheckedTimeoutException	Unchecked version of `TimeoutException`.

Error Summary
Error Description

ExecutionError
Error variant of ExecutionException.

Error Summary
Error	Description
ExecutionError	`Error` variant of `ExecutionException`.

Package com.google.common.util.concurrent Description

Concurrency utilities.

Commonly used types include ListenableFuture and Service.

Commonly used utilities include Futures, MoreExecutors, and ThreadFactoryBuilder.

This package is a part of the open-source Guava library.