| Package | Description |
|---|---|
| com.google.common.cache |
This package contains caching utilities.
|
| com.google.common.util.concurrent |
Concurrency utilities.
|
| Class and Description |
|---|
| ListenableFuture
A
Future that accepts completion listeners. |
| SettableFuture
A
ListenableFuture whose result may be set by a SettableFuture.set(Object)
or SettableFuture.setException(Throwable) call. |
| Class and Description |
|---|
| AbstractCheckedFuture
A delegating wrapper around a
ListenableFuture that adds support for
the AbstractCheckedFuture.checkedGet() and AbstractCheckedFuture.checkedGet(long, TimeUnit) methods. |
| AbstractFuture
An abstract implementation of the
ListenableFuture interface. |
| AbstractFuture.Sync
Following the contract of
AbstractQueuedSynchronizer we create a
private subclass to hold the synchronizer. |
| AbstractListeningExecutorService
Abstract
ListeningExecutorService implementation that creates
ListenableFutureTask instances for each Runnable and Callable submitted
to it. |
| 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.
|
| AsyncFunction
Transforms a value, possibly asynchronously.
|
| AsyncSettableFuture
A settable future that can be set asynchronously via
AsyncSettableFuture.setFuture(com.google.common.util.concurrent.ListenableFuture<? extends V>). |
| AsyncSettableFuture.NestedFuture |
| AtomicDouble
A
double value that may be updated atomically. |
| AtomicLongMap
A map containing
long values that can be atomically updated. |
| CheckedFuture
A
CheckedFuture is a ListenableFuture that includes versions
of the get methods that can throw a checked exception. |
| CycleDetectingLockFactory
The
CycleDetectingLockFactory creates ReentrantLock instances and
ReentrantReadWriteLock instances that detect potential deadlock by checking
for cycles in lock acquisition order. |
| CycleDetectingLockFactory.CycleDetectingLock
Internal Lock implementations implement the
CycleDetectingLock
interface, allowing the detection logic to treat all locks in the same
manner. |
| CycleDetectingLockFactory.CycleDetectingReentrantReadLock |
| CycleDetectingLockFactory.CycleDetectingReentrantReadWriteLock |
| CycleDetectingLockFactory.CycleDetectingReentrantWriteLock |
| CycleDetectingLockFactory.ExampleStackTrace
A Throwable used to record a stack trace that illustrates an example of
a specific lock acquisition ordering.
|
| CycleDetectingLockFactory.LockGraphNode
A
LockGraphNode associated with each lock instance keeps track of
the directed edges in the lock acquisition graph. |
| CycleDetectingLockFactory.Policies
Pre-defined
CycleDetectingLockFactory.Policy implementations. |
| CycleDetectingLockFactory.Policy
Encapsulates the action to be taken when a potential deadlock is
encountered.
|
| CycleDetectingLockFactory.PotentialDeadlockException
Represents a detected cycle in lock acquisition ordering.
|
| CycleDetectingLockFactory.WithExplicitOrdering
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 |
| ForwardingCheckedFuture
A future which forwards all its method calls to another future.
|
| ForwardingExecutorService
An executor service which forwards all its method calls to another executor
service.
|
| ForwardingFuture
A
Future which forwards all its method calls to another future. |
| ForwardingListenableFuture
A
ListenableFuture which forwards all its method calls to another
future. |
| ForwardingListenableFuture.SimpleForwardingListenableFuture
A simplified version of
ForwardingListenableFuture where subclasses
can pass in an already constructed ListenableFuture
as the delegate. |
| FutureCallback
A callback for accepting the results of a
Future
computation asynchronously. |
| FutureFallback
Provides a backup
Future to replace an earlier failed Future. |
| Futures.CombinerFuture |
| Futures.FutureCombiner |
| Futures.ImmediateFuture |
| ListenableFuture
A
Future that accepts completion listeners. |
| ListenableFutureTask
A
FutureTask that also implements the ListenableFuture
interface. |
| ListenableScheduledFuture
Helper interface to implement both
ListenableFuture and
ScheduledFuture. |
| ListenerCallQueue
A special purpose queue/executor that executes listener callbacks serially on a configured
executor.
|
| ListenerCallQueue.Callback |
| ListeningExecutorService
An
ExecutorService that returns ListenableFuture instances. |
| ListeningScheduledExecutorService
A
ScheduledExecutorService that returns ListenableFuture
instances from its ExecutorService methods. |
| Monitor
A synchronization abstraction supporting waiting on arbitrary boolean conditions.
|
| Monitor.Guard
A boolean condition for which a thread may wait.
|
| MoreExecutors.DirectExecutor
See
MoreExecutors.directExecutor() for behavioral notes. |
| MoreExecutors.ListeningDecorator |
| RateLimiter
A rate limiter.
|
| RateLimiter.SleepingStopwatch |
| SerializingExecutor.TaskRunner
Task that actually runs the Runnables.
|
| Service
An object with an operational state, plus asynchronous
Service.startAsync() and
Service.stopAsync() lifecycle methods to transition between states. |
| Service.Listener
A listener for the various state changes that a
Service goes through in its lifecycle. |
| Service.State
The lifecycle states of a service.
|
| 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.
|
| ServiceManager.ServiceManagerState
An encapsulation of all the mutable state of the
ServiceManager that needs to be
accessed by instances of ServiceManager.ServiceListener. |
| SettableFuture
A
ListenableFuture whose result may be set by a SettableFuture.set(Object)
or SettableFuture.setException(Throwable) call. |
| SmoothRateLimiter |
| Striped
A striped
Lock/Semaphore/ReadWriteLock. |
| Striped.PowerOfTwoStriped |
| Striped.SmallLazyStriped.ArrayReference |
| 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
|
| TimeLimiter
Produces proxies that impose a time limit on method
calls to the proxied object.
|
| WrappingExecutorService
An abstract
ExecutorService that allows subclasses to
wrap tasks before they are submitted
to the underlying executor. |