| AbstractCatchingFuture |
Implementations of Futures.catching*.
|
| AbstractFuture |
An abstract implementation of ListenableFuture, intended for advanced users only.
|
| AbstractFuture.AtomicHelper |
|
| AbstractFuture.Cancellation |
A special value to represent cancellation and the 'wasInterrupted' bit.
|
| AbstractFuture.Failure |
|
| AbstractFuture.Listener |
|
| AbstractFuture.Trusted |
Tag interface marking trusted subclasses.
|
| AbstractFuture.TrustedFuture |
A less abstract subclass of AbstractFuture.
|
| AbstractFuture.Waiter |
|
| AbstractListeningExecutorService |
|
| AbstractScheduledService.CustomScheduler.Schedule |
A value object that represents an absolute delay until a task should be invoked.
|
| AbstractScheduledService.Scheduler |
|
| AbstractService |
|
| AbstractService.StateSnapshot |
An immutable snapshot of the current state of the service.
|
| AbstractTransformFuture |
Implementations of Futures.transform*.
|
| AggregateFuture |
A future whose value is derived from a collection of input futures.
|
| AggregateFuture.ReleaseResourcesReason |
|
| AggregateFutureState |
A helper which does some thread-safe operations for aggregate futures, which must be implemented
differently in GWT.
|
| AggregateFutureState.AtomicHelper |
|
| AsyncCallable |
Computes a value, possibly asynchronously.
|
| AsyncFunction |
Transforms a value, possibly asynchronously.
|
| AtomicDouble |
A double value that may be updated atomically.
|
| AtomicLongMap |
A map containing long values that can be atomically updated.
|
| ClosingFuture |
A step in a pipeline of an asynchronous computation.
|
| ClosingFuture.AsyncClosingCallable |
|
| ClosingFuture.AsyncClosingFunction |
|
| ClosingFuture.CloseableList |
|
| ClosingFuture.ClosingCallable |
An operation that computes a result.
|
| ClosingFuture.ClosingFunction |
A function from an input to a result.
|
| ClosingFuture.Combiner |
A builder of a ClosingFuture step that is derived from more than one input step.
|
| ClosingFuture.Combiner.AsyncCombiningCallable |
An operation that returns a ClosingFuture result and may throw an exception.
|
| ClosingFuture.Combiner.CombiningCallable |
An operation that returns a result and may throw an exception.
|
| ClosingFuture.Combiner2 |
|
| ClosingFuture.Combiner2.AsyncClosingFunction2 |
|
| ClosingFuture.Combiner2.ClosingFunction2 |
|
| ClosingFuture.Combiner3 |
|
| ClosingFuture.Combiner3.AsyncClosingFunction3 |
|
| ClosingFuture.Combiner3.ClosingFunction3 |
|
| ClosingFuture.Combiner4 |
|
| ClosingFuture.Combiner4.AsyncClosingFunction4 |
|
| ClosingFuture.Combiner4.ClosingFunction4 |
|
| ClosingFuture.Combiner5 |
|
| ClosingFuture.Combiner5.AsyncClosingFunction5 |
|
| ClosingFuture.Combiner5.ClosingFunction5 |
|
| ClosingFuture.DeferredCloser |
An object that can capture objects to be closed later, when a ClosingFuture pipeline is
done.
|
| ClosingFuture.Peeker |
|
| ClosingFuture.State |
|
| ClosingFuture.ValueAndCloser |
An object that holds the final result of an asynchronous ClosingFuture operation and
allows the user to close all the closeable objects that were captured during it for later
closing.
|
| ClosingFuture.ValueAndCloserConsumer |
|
| CollectionFuture |
Aggregate future that collects (stores) results of each future.
|
| CollectionFuture.Present |
The result of a successful Future.
|
| CombinedFuture.CombinedFutureInterruptibleTask |
|
| 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 |
|
| 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.
|
| DirectExecutor |
An Executor that runs each task in the thread that invokes execute.
|
| ExecutionList |
A support class for ListenableFuture implementations to manage their listeners.
|
| ExecutionList.RunnableExecutorPair |
|
| 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).
|
| ExecutionSequencer.RunningState |
|
| ExecutionSequencer.ThreadConfinedTaskQueue |
This object is unsafely published, but avoids problematic races by relying exclusively on the
identity equality of its Thread field so that the task field is only accessed by a single
thread.
|
| FluentFuture |
|
| FluentFuture.TrustedFuture |
A less abstract subclass of AbstractFuture.
|
| ForwardingCondition |
Forwarding wrapper around a Condition.
|
| 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 |
|
| ForwardingListenableFuture.SimpleForwardingListenableFuture |
|
| ForwardingLock |
Forwarding wrapper around a Lock.
|
| FutureCallback |
A callback for accepting the results of a Future computation
asynchronously.
|
| Futures.FutureCombiner |
A helper to create a new ListenableFuture whose result is generated from a combination
of input futures.
|
| Futures.InCompletionOrderState |
|
| FuturesGetChecked.GetCheckedTypeValidator |
|
| FuturesGetChecked.GetCheckedTypeValidatorHolder.ClassValueValidator |
|
| FuturesGetChecked.GetCheckedTypeValidatorHolder.WeakSetValidator |
|
| GwtFluentFutureCatchingSpecialization |
Hidden superclass of FluentFuture that provides us a place to declare special GWT
versions of the FluentFuture.catching family of methods.
|
| GwtFuturesCatchingSpecialization |
Hidden superclass of Futures that provides us a place to declare special GWT versions of
the Futures.catching family of methods.
|
| IgnoreJRERequirement |
|
| InterruptibleTask |
|
| ListenableFuture |
A Future that accepts completion listeners.
|
| ListenableFutureTask |
|
| ListenableScheduledFuture |
|
| ListenerCallQueue |
A list of listeners for implementing a concurrency friendly observable object.
|
| ListenerCallQueue.Event |
Method reference-compatible listener event.
|
| ListenerCallQueue.PerListenerQueue |
A special purpose queue/executor that dispatches listener events serially on a configured
executor.
|
| ListeningExecutorService |
|
| 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.ListeningDecorator |
|
| Partially.GwtIncompatible |
The presence of this annotation on an API indicates that the method may be used with the
Google Web Toolkit (GWT) but that it has some
restrictions.
|
| RateLimiter |
A rate limiter.
|
| RateLimiter.SleepingStopwatch |
|
| SequentialExecutor.QueueWorker |
|
| SequentialExecutor.WorkerRunningState |
|
| Service |
|
| 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 |
|
| 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.
|
| SettableFuture |
|
| SimpleTimeLimiter |
A TimeLimiter that runs method calls in the background using an ExecutorService.
|
| SmoothRateLimiter |
|
| Striped |
A striped Lock/Semaphore/ReadWriteLock.
|
| Striped.PowerOfTwoStriped |
|
| Striped.SmallLazyStriped.ArrayReference |
|
| Striped.WeakSafeReadWriteLock |
ReadWriteLock implementation whose read and write locks retain a reference back to this lock.
|
| 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 |
Imposes a time limit on method calls.
|
| TimeoutFuture |
Implementation of Futures#withTimeout.
|
| TrustedListenableFutureTask |
|
| WrappingExecutorService |
An abstract ExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor.
|