@ParametersAreNonnullByDefault

## Package com.google.common.util.concurrent

Concurrency utilities.

See:
Description

Interface Summary
AsyncFunction<I,O>: Transforms a value, possibly asynchronously.
CheckedFuture<V,X extends Exception>: A `CheckedFuture` is a `ListenableFuture` that includes versions of the `get` methods that can throw a checked exception.
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.
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.start()` and `Service.stop()` lifecycle methods to transition between states.
Service.Listener: A listener for the various state changes that a `Service` goes through in its lifecycle.
TimeLimiter: Produces proxies that impose a time limit on method calls to the proxied object.

Class Summary
AbstractCheckedFuture<V,X extends 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.
AbstractIdleService: Base class for services that do not need a thread while "running" but may need one during startup and shutdown.
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`s and `ReentrantReadWriteLock`s 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 list of listeners, each with an associated `Executor`, that guarantees that every `Runnable` that is added will be executed after `ExecutionList.execute()` is called.
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 Exception>: A future which forwards all its method calls to another future.
ForwardingCheckedFuture.SimpleForwardingCheckedFuture<V,X extends 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 `ForwardingFuture.SimpleForwardingFuture` 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 `ForwardingListenableFuture.SimpleForwardingListenableFuture` 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.
ForwardingService: A `Service` that forwards all method calls to another service.
Futures: Static utility methods pertaining to the `Future` interface.
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.
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`.
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 If no backing thread factory is provided, a default backing thread factory is used as if by calling `setThreadFactory(``Executors.defaultThreadFactory()``)`.
UncaughtExceptionHandlers: Factories for `Thread.UncaughtExceptionHandler` instances.
Uninterruptibles: Utilities for treating interruptible operations as uninterruptible.

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

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

Error Summary
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.

Copyright © 2010-2012. All Rights Reserved.