Package | Description |
---|---|
com.google.common.util.concurrent |
Concurrency utilities.
|
Modifier and Type | Class and Description |
---|---|
(package private) class |
AbstractCatchingFuture<V,X extends java.lang.Throwable,F,T>
Implementations of
Futures.catching* . |
class |
AbstractExecutionThreadService
Base class for services that can implement
AbstractExecutionThreadService.startUp() , AbstractExecutionThreadService.run() and AbstractExecutionThreadService.shutDown()
methods. |
class |
AbstractFuture<V>
An abstract implementation of
ListenableFuture , intended for advanced users only. |
class |
AbstractIdleService
Base class for services that do not need a thread while "running" but may need one during startup
and shutdown.
|
class |
AbstractListeningExecutorService
Abstract
ListeningExecutorService implementation that creates ListenableFuture
instances for each Runnable and Callable submitted to it. |
class |
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. |
class |
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. |
(package private) class |
AbstractTransformFuture<I,O,F,T>
Implementations of
Futures.transform* . |
(package private) class |
AggregateFuture<InputT,OutputT>
A future whose value is derived from a collection of input futures.
|
(package private) class |
AggregateFutureState<OutputT>
A helper which does some thread-safe operations for aggregate futures, which must be implemented
differently in GWT.
|
interface |
AsyncCallable<V>
Computes a value, possibly asynchronously.
|
interface |
AsyncFunction<I,O>
Transforms a value, possibly asynchronously.
|
class |
AtomicDouble
A
double value that may be updated atomically. |
class |
AtomicDoubleArray
A
double array in which elements may be updated atomically. |
class |
AtomicLongMap<K>
A map containing
long values that can be atomically updated. |
class |
Atomics
Static utility methods pertaining to classes in the
java.util.concurrent.atomic package. |
class |
Callables
Static utility methods pertaining to the
Callable interface. |
class |
ClosingFuture<V>
A step in a pipeline of an asynchronous computation.
|
(package private) class |
CollectionFuture<V,C>
Aggregate future that collects (stores) results of each future.
|
(package private) class |
CombinedFuture<V>
Aggregate future that computes its value by calling a callable.
|
class |
CycleDetectingLockFactory
The
CycleDetectingLockFactory creates ReentrantLock instances and ReentrantReadWriteLock instances that detect potential deadlock by checking for cycles in lock
acquisition order. |
(package private) class |
DirectExecutor
An
Executor that runs each task in the thread that invokes execute . |
class |
ExecutionError
Error variant of ExecutionException . |
class |
ExecutionList
A support class for
ListenableFuture implementations to manage their listeners. |
class |
ExecutionSequencer
Serializes execution of tasks, somewhat like an "asynchronous
synchronized block." Each
enqueued callable will not be submitted to its associated executor until the
previous callable has returned -- and, if the previous callable was an AsyncCallable , not
until the Future it returned is done (successful, failed, or
cancelled). |
class |
FakeTimeLimiter
A TimeLimiter implementation which actually does not attempt to limit time at all.
|
class |
FluentFuture<V>
A
ListenableFuture that supports fluent chains of operations. |
class |
ForwardingBlockingDeque<E>
A
BlockingDeque which forwards all its method calls to another BlockingDeque . |
class |
ForwardingBlockingQueue<E>
A
BlockingQueue which forwards all its method calls to another BlockingQueue . |
(package private) class |
ForwardingCondition
Forwarding wrapper around a
Condition . |
class |
ForwardingExecutorService
An executor service which forwards all its method calls to another executor service.
|
(package private) class |
ForwardingFluentFuture<V>
FluentFuture that forwards all calls to a delegate. |
class |
ForwardingFuture<V>
A
Future which forwards all its method calls to another future. |
class |
ForwardingListenableFuture<V>
A
ListenableFuture which forwards all its method calls to another future. |
class |
ForwardingListeningExecutorService
A listening executor service which forwards all its method calls to another listening executor
service.
|
(package private) class |
ForwardingLock
Forwarding wrapper around a
Lock . |
interface |
FutureCallback<V>
A callback for accepting the results of a
Future computation
asynchronously. |
class |
Futures
Static utility methods pertaining to the
Future interface. |
(package private) class |
FuturesGetChecked
Static methods used to implement
Futures.getChecked(Future, Class) . |
(package private) class |
GwtFluentFutureCatchingSpecialization<V>
Hidden superclass of
FluentFuture that provides us a place to declare special GWT
versions of the FluentFuture.catching family of methods. |
(package private) class |
GwtFuturesCatchingSpecialization
Hidden superclass of
Futures that provides us a place to declare special GWT versions of
the Futures.catching family of methods. |
(package private) class |
ImmediateFuture<V>
Implementation of
Futures.immediateFuture(V) . |
(package private) class |
Internal
This class is for
com.google.common.util.concurrent use only! |
(package private) class |
InterruptibleTask<T> |
class |
JdkFutureAdapters
Utilities necessary for working with libraries that supply plain
Future instances. |
interface |
ListenableFuture<V>
A
Future that accepts completion listeners. |
class |
ListenableFutureTask<V>
A
FutureTask that also implements the ListenableFuture interface. |
interface |
ListenableScheduledFuture<V>
Helper interface to implement both
ListenableFuture and ScheduledFuture . |
(package private) class |
ListenerCallQueue<L>
A list of listeners for implementing a concurrency friendly observable object.
|
interface |
ListeningExecutorService
An
ExecutorService that returns ListenableFuture instances. |
interface |
ListeningScheduledExecutorService
A
ScheduledExecutorService that returns ListenableFuture instances from its
ExecutorService methods. |
class |
Monitor
A synchronization abstraction supporting waiting on arbitrary boolean conditions.
|
class |
MoreExecutors
Factory and utility methods for
Executor , ExecutorService ,
and ThreadFactory . |
(package private) class |
NullnessCasts
A utility method to perform unchecked casts to suppress errors produced by nullness analyses.
|
(package private) class |
OverflowAvoidingLockSupport
Works around an android bug, where parking for more than INT_MAX seconds can produce an abort
signal on 32 bit devices running Android Q.
|
(package private) class |
Partially
Outer class that exists solely to let us write
Partially.GwtIncompatible instead of plain
GwtIncompatible . |
(package private) class |
Platform
Methods factored out so that they can be emulated differently in GWT.
|
class |
RateLimiter
A rate limiter.
|
class |
Runnables
Static utility methods pertaining to the
Runnable interface. |
(package private) class |
SequentialExecutor
Executor ensuring that all Runnables submitted are executed in order, using the provided
Executor, and sequentially such that no two will ever be running at the same time.
|
interface |
Service
An object with an operational state, plus asynchronous
Service.startAsync() and Service.stopAsync() lifecycle methods to transition between states. |
class |
ServiceManager
A manager for monitoring and controlling a set of services.
|
(package private) interface |
ServiceManagerBridge
Superinterface of
ServiceManager to introduce a bridge method for servicesByState() , to ensure binary compatibility with older Guava versions that specified
servicesByState() to return ImmutableMultimap . |
class |
SettableFuture<V>
A
ListenableFuture whose result can be set by a SettableFuture.set(Object) , SettableFuture.setException(Throwable) or SettableFuture.setFuture(ListenableFuture) call. |
class |
SimpleTimeLimiter
A TimeLimiter that runs method calls in the background using an
ExecutorService . |
(package private) class |
SmoothRateLimiter |
class |
Striped<L>
A striped
Lock/Semaphore/ReadWriteLock . |
class |
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
|
interface |
TimeLimiter
Imposes a time limit on method calls.
|
(package private) class |
TimeoutFuture<V>
Implementation of
Futures#withTimeout . |
(package private) class |
TrustedListenableFutureTask<V>
A
RunnableFuture that also implements the ListenableFuture interface. |
class |
UncaughtExceptionHandlers
Factories for
Thread.UncaughtExceptionHandler instances. |
class |
UncheckedExecutionException
Unchecked variant of
ExecutionException . |
class |
UncheckedTimeoutException
Unchecked version of
TimeoutException . |
class |
Uninterruptibles
Utilities for treating interruptible operations as uninterruptible.
|
(package private) class |
WrappingExecutorService
An abstract
ExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor. |
(package private) class |
WrappingScheduledExecutorService
An abstract
ScheduledExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor. |