com.google.common.util.concurrent

Interface Summary
Interface	Description
AsyncFunction<I,O>	Transforms a value, possibly asynchronously.
CheckedFuture<V,X extends java.lang.Exception>	A `CheckedFuture` is a `ListenableFuture` that includes versions of the `get` methods that can throw a checked exception.
CycleDetectingLockFactory.CycleDetectingLock	Internal Lock implementations implement the `CycleDetectingLock` interface, allowing the detection logic to treat all locks in the same manner.
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.
FutureFallback<V>	Provides a backup `Future` to replace an earlier failed `Future`.
Futures.FutureCombiner<V,C>
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	Produces proxies that impose a time limit on method calls to the proxied object.

Class Summary
Class	Description
AbstractCheckedFuture<V,X extends java.lang.Exception>	A delegating wrapper around a `ListenableFuture` that adds support for the `AbstractCheckedFuture.checkedGet()` and `AbstractCheckedFuture.checkedGet(long, TimeUnit)` methods.
AbstractExecutionThreadService	Base class for services that can implement `AbstractExecutionThreadService.startUp()`, `AbstractExecutionThreadService.run()` and `AbstractExecutionThreadService.shutDown()` methods.
AbstractFuture<V>	An abstract implementation of the `ListenableFuture` interface.
AbstractFuture.Sync<V>	Following the contract of `AbstractQueuedSynchronizer` we create a private subclass to hold the synchronizer.
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 `ListenableFutureTask` 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.
AbstractService.StateSnapshot	An immutable snapshot of the current state of the service.
AsyncSettableFuture<V>	A settable future that can be set asynchronously via `AsyncSettableFuture.setFuture(com.google.common.util.concurrent.ListenableFuture<? extends V>)`.
AsyncSettableFuture.NestedFuture<V>
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.LockGraphNode	A `LockGraphNode` associated with each lock instance keeps track of the directed edges in the lock acquisition graph.
CycleDetectingLockFactory.WithExplicitOrdering<E extends java.lang.Enum<E>>	A `CycleDetectingLockFactory.WithExplicitOrdering` provides the additional enforcement of an application-specified ordering of lock acquisitions.
ExecutionList	A list of listeners, each with an associated `Executor`, that guarantees that every `Runnable` that is added will be executed after `ExecutionList.execute()` is called.
ExecutionList.RunnableExecutorPair
FakeTimeLimiter	A TimeLimiter implementation which actually does not attempt to limit time at all.
ForwardingBlockingQueue<E>	A `BlockingQueue` which forwards all its method calls to another `BlockingQueue`.
ForwardingCheckedFuture<V,X extends java.lang.Exception>	A future which forwards all its method calls to another future.
ForwardingCheckedFuture.SimpleForwardingCheckedFuture<V,X extends java.lang.Exception>	A simplified version of `ForwardingCheckedFuture` where subclasses can pass in an already constructed `CheckedFuture` as the delegate.
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.ChainingListenableFuture<I,O>	An implementation of `ListenableFuture` that also implements `Runnable` so that it can be used to nest ListenableFutures.
Futures.CombinedFuture<V,C>
Futures.CombinerFuture<V>
Futures.FallbackFuture<V>	A future that falls back on a second, generated future, in case its original future fails.
Futures.ImmediateCancelledFuture<V>
Futures.ImmediateFailedCheckedFuture<V,X extends java.lang.Exception>
Futures.ImmediateFailedFuture<V>
Futures.ImmediateFuture<V>
Futures.ImmediateSuccessfulCheckedFuture<V,X extends java.lang.Exception>
Futures.ImmediateSuccessfulFuture<V>
Futures.MappingCheckedFuture<V,X extends java.lang.Exception>	A checked future that uses a function to map from exceptions to the appropriate checked type.
Futures.NonCancellationPropagatingFuture<V>	A wrapped future that does not propagate cancellation to its delegate.
Futures.WrappedCombiner<T>
JdkFutureAdapters	Utilities necessary for working with libraries that supply plain `Future` instances.
JdkFutureAdapters.ListenableFutureAdapter<V>	An adapter to turn a `Future` into a `ListenableFuture`.
ListenableFutureTask<V>	A `FutureTask` that also implements the `ListenableFuture` interface.
ListenerCallQueue<L>	A special purpose queue/executor that executes listener callbacks serially on a configured executor.
ListenerCallQueue.Callback<L>
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`.
MoreExecutors.Application	Represents the current application to register shutdown hooks.
MoreExecutors.DirectExecutorService
MoreExecutors.ListeningDecorator
MoreExecutors.ScheduledListeningDecorator
MoreExecutors.ScheduledListeningDecorator.ListenableScheduledTask<V>
MoreExecutors.ScheduledListeningDecorator.NeverSuccessfulListenableFutureTask
RateLimiter	A rate limiter.
RateLimiter.SleepingStopwatch
Runnables	Static utility methods pertaining to the `Runnable` interface.
SerializingExecutor	Executor ensuring that all Runnables submitted are executed in order, using the provided Executor, and serially such that no two will ever be running at the same time.
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.EmptyServiceManagerWarning	This is never thrown but only used for logging.
ServiceManager.Listener	A listener for the aggregate state changes of the services that are under management.
ServiceManager.NoOpService	A `Service` instance that does nothing.
ServiceManager.ServiceListener	A `Service` that wraps another service and times how long it takes for it to start and also calls the `ServiceManagerState#transitionService(Service, State, State)`, to record the state transitions.
ServiceManager.ServiceManagerState	An encapsulation of all the mutable state of the `ServiceManager` that needs to be accessed by instances of `ServiceManager.ServiceListener`.
SettableFuture<V>	A `ListenableFuture` whose result may be set by a `SettableFuture.set(Object)` or `SettableFuture.setException(Throwable)` call.
SimpleTimeLimiter	A TimeLimiter that runs method calls in the background using an `ExecutorService`.
SmoothRateLimiter
SmoothRateLimiter.SmoothBursty	This implements a "bursty" RateLimiter, where storedPermits are translated to zero throttling.
SmoothRateLimiter.SmoothWarmingUp	This implements the following function: ^ throttling \| 3*stable + / interval \| /.
Striped<L>	A striped `Lock/Semaphore/ReadWriteLock`.
Striped.CompactStriped<L>	Implementation of Striped where 2^k stripes are represented as an array of the same length, eagerly initialized.
Striped.LargeLazyStriped<L>	Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap where the key domain is [0..2^k).
Striped.PaddedLock
Striped.PaddedSemaphore
Striped.PowerOfTwoStriped<L>
Striped.SmallLazyStriped<L>	Implementation of Striped where up to 2^k stripes can be represented, using an AtomicReferenceArray of size 2^k.
Striped.SmallLazyStriped.ArrayReference<L>
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.
UncaughtExceptionHandlers.Exiter
Uninterruptibles	Utilities for treating interruptible operations as uninterruptible.
WrappingExecutorService	An abstract `ExecutorService` that allows subclasses to wrap tasks before they are submitted to the underlying executor.
WrappingScheduledExecutorService	An abstract `ScheduledExecutorService` that allows subclasses to wrap tasks before they are submitted to the underlying executor.

Enum Summary
Enum	Description
CycleDetectingLockFactory.Policies	Pre-defined `CycleDetectingLockFactory.Policy` implementations.
MoreExecutors.DirectExecutor	See `MoreExecutors.directExecutor()` for behavioral notes.
Service.State	The lifecycle states of a service.

Exception Summary
Exception	Description
CycleDetectingLockFactory.ExampleStackTrace	A Throwable used to record a stack trace that illustrates an example of a specific lock acquisition ordering.
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 libraries.