Uses of Annotation Interface
com.google.common.util.concurrent.ElementTypesAreNonnullByDefault
Packages that use ElementTypesAreNonnullByDefault
-
Uses of ElementTypesAreNonnullByDefault in com.google.common.util.concurrent
Classes in com.google.common.util.concurrent with annotations of type ElementTypesAreNonnullByDefaultModifier and TypeClassDescription(package private) class
AbstractCatchingFuture<V,
X extends Throwable, F, T> Implementations ofFutures.catching*
.class
Base class for services that can implementAbstractExecutionThreadService.startUp()
,AbstractExecutionThreadService.run()
andAbstractExecutionThreadService.shutDown()
methods.class
An abstract implementation ofListenableFuture
, intended for advanced users only.class
Base class for services that do not need a thread while "running" but may need one during startup and shutdown.class
AbstractListeningExecutorService
implementation that createsListenableFuture
instances for eachRunnable
andCallable
submitted to it.class
Base class for services that can implementAbstractScheduledService.startUp()
andAbstractScheduledService.shutDown()
but while in the "running" state need to perform a periodic task.class
Base class for implementing services that can handleAbstractService.doStart()
andAbstractService.doStop()
requests, responding to them withAbstractService.notifyStarted()
andAbstractService.notifyStopped()
callbacks.(package private) class
AbstractTransformFuture<I,
O, F, T> Implementations ofFutures.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
Computes a value, possibly asynchronously.interface
AsyncFunction<I,
O> Transforms a value, possibly asynchronously.class
Adouble
value that may be updated atomically.class
Adouble
array in which elements may be updated atomically.final class
A map containinglong
values that can be atomically updated.final class
Static utility methods pertaining to classes in thejava.util.concurrent.atomic
package.final class
Static utility methods pertaining to theCallable
interface.final class
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) final class
Aggregate future that computes its value by calling a callable.class
TheCycleDetectingLockFactory
createsReentrantLock
instances andReentrantReadWriteLock
instances that detect potential deadlock by checking for cycles in lock acquisition order.(package private) enum
(package private) final class
See newDirectExecutorService javadoc for behavioral notes.class
Error
variant ofExecutionException
.final class
A support class forListenableFuture
implementations to manage their listeners.final class
Serializes execution of tasks, somewhat like an "asynchronoussynchronized
block." Each enqueued callable will not be submitted to its associated executor until the previous callable has returned -- and, if the previous callable was anAsyncCallable
, not until theFuture
it returned isinvalid reference
done
final class
A TimeLimiter implementation which actually does not attempt to limit time at all.class
FluentFuture<V>
AListenableFuture
that supports fluent chains of operations.class
ABlockingDeque
which forwards all its method calls to anotherBlockingDeque
.class
ABlockingQueue
which forwards all its method calls to anotherBlockingQueue
.(package private) class
Forwarding wrapper around aCondition
.class
An executor service which forwards all its method calls to another executor service.(package private) final class
FluentFuture
that forwards all calls to a delegate.class
AFuture
which forwards all its method calls to another future.class
AListenableFuture
which forwards all its method calls to another future.class
A listening executor service which forwards all its method calls to another listening executor service.(package private) class
Forwarding wrapper around aLock
.interface
A callback for accepting the results of aFuture
computation asynchronously.final class
Static utility methods pertaining to theFuture
interface.(package private) final class
Static methods used to implementFutures.getChecked(Future, Class)
.(package private) class
Hidden superclass ofFluentFuture
that provides us a place to declare special GWT versions of theinvalid reference
FluentFuture.catching
(package private) class
Hidden superclass ofFutures
that provides us a place to declare special GWT versions of theFutures.catching
family of methods.(package private) class
Implementation ofFutures.immediateFuture(V)
.(package private) final class
This class is forcom.google.common.util.concurrent
use only!(package private) class
final class
Utilities necessary for working with libraries that supply plainFuture
instances.(package private) final class
A holder for aLogger
that is initialized only when requested.interface
AFuture
that accepts completion listeners.class
AFutureTask
that also implements theListenableFuture
interface.interface
Helper interface to implement bothListenableFuture
andScheduledFuture
.(package private) final class
A list of listeners for implementing a concurrency friendly observable object.interface
AnExecutorService
that returnsListenableFuture
instances.interface
AScheduledExecutorService
that returnsListenableFuture
instances from itsExecutorService
methods.final class
A synchronization abstraction supporting waiting on arbitrary boolean conditions.final class
(package private) final class
A utility method to perform unchecked casts to suppress errors produced by nullness analyses.(package private) final class
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) final class
Outer class that exists solely to let us writePartially.GwtIncompatible
instead of plainGwtIncompatible
.(package private) final class
Methods factored out so that they can be emulated differently in GWT.class
A rate limiter.final class
Static utility methods pertaining to theRunnable
interface.(package private) final class
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
An object with an operational state, plus asynchronousService.startAsync()
andService.stopAsync()
lifecycle methods to transition between states.final class
A manager for monitoring and controlling a set of services.(package private) interface
Superinterface ofServiceManager
to introduce a bridge method forservicesByState()
, to ensure binary compatibility with older Guava versions that specifiedservicesByState()
to returnImmutableMultimap
.final class
AListenableFuture
whose result can be set by aSettableFuture.set(Object)
,SettableFuture.setException(Throwable)
orSettableFuture.setFuture(ListenableFuture)
call.final class
A TimeLimiter that runs method calls in the background using anExecutorService
.(package private) class
class
Striped<L>
A stripedLock/Semaphore/ReadWriteLock
.final class
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 factoryinterface
Imposes a time limit on method calls.(package private) final class
Implementation ofFutures#withTimeout
.(package private) class
ARunnableFuture
that also implements theListenableFuture
interface.final class
Factories forThread.UncaughtExceptionHandler
instances.class
Unchecked variant ofExecutionException
.class
Unchecked version ofTimeoutException
.final class
Utilities for treating interruptible operations as uninterruptible.(package private) class
An abstractExecutorService
that allows subclasses to wrap tasks before they are submitted to the underlying executor.(package private) class
An abstractScheduledExecutorService
that allows subclasses to wrap tasks before they are submitted to the underlying executor.