@GwtCompatible final class ForwardingFluentFuture<V> extends FluentFuture<V>
FluentFuture
that forwards all calls to a delegate.
FluentFuture
but with extra methods, we recommend declaring your
own subclass of ListenableFuture
, complete with a method like FluentFuture.from(com.google.common.util.concurrent.ListenableFuture<V>)
to adapt an
existing ListenableFuture
, implemented atop a ForwardingListenableFuture
that
forwards to that future and adds the desired methods.FluentFuture.TrustedFuture<V>
AbstractFuture.Trusted<V>
Modifier and Type | Field and Description |
---|---|
private ListenableFuture<V> |
delegate |
Constructor and Description |
---|
ForwardingFluentFuture(ListenableFuture<V> delegate) |
Modifier and Type | Method and Description |
---|---|
void |
addListener(java.lang.Runnable listener,
java.util.concurrent.Executor executor)
Registers a listener to be run on the given executor.
|
boolean |
cancel(boolean mayInterruptIfRunning) |
V |
get() |
V |
get(long timeout,
java.util.concurrent.TimeUnit unit) |
boolean |
isCancelled() |
boolean |
isDone() |
java.lang.String |
toString() |
addCallback, catching, catchingAsync, from, from, transform, transformAsync, withTimeout, withTimeout
afterDone, interruptTask, maybePropagateCancellationTo, pendingToString, set, setException, setFuture, tryInternalFastPathGetFailure, wasInterrupted
private final ListenableFuture<V> delegate
ForwardingFluentFuture(ListenableFuture<V> delegate)
public void addListener(java.lang.Runnable listener, java.util.concurrent.Executor executor)
AbstractFuture
Future
's computation is complete or, if the computation is already complete, immediately.
There is no guaranteed ordering of execution of listeners, but any listener added through this method is guaranteed to be called once the computation is complete.
Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown
during Executor.execute
(e.g., a RejectedExecutionException
or an exception
thrown by direct execution) will be caught and
logged.
Note: For fast, lightweight listeners that would be safe to execute in any thread, consider
MoreExecutors.directExecutor()
. Otherwise, avoid it. Heavyweight directExecutor
listeners can cause problems, and these problems can be difficult to reproduce because they
depend on timing. For example:
addListener
. That caller may be a
UI thread or other latency-sensitive thread. This can harm UI responsiveness.
Future
. That
thread may be an internal system thread such as an RPC network thread. Blocking that
thread may stall progress of the whole system. It may even cause a deadlock.
directExecutor
listeners.
This is the most general listener interface. For common operations performed using
listeners, see Futures
. For a simplified but general listener interface, see addCallback()
.
Memory consistency effects: Actions in a thread prior to adding a listener happen-before its execution begins, perhaps in another thread.
Guava implementations of ListenableFuture
promptly release references to listeners
after executing them.
addListener
in interface ListenableFuture<V>
addListener
in class AbstractFuture<V>
listener
- the listener to run when the computation is completeexecutor
- the executor to run the listener inpublic boolean cancel(boolean mayInterruptIfRunning)
AbstractFuture
If a cancellation attempt succeeds on a Future
that had previously been set asynchronously, then the cancellation will also be propagated to the delegate
Future
that was supplied in the setFuture
call.
Rather than override this method to perform additional cancellation work or cleanup,
subclasses should override AbstractFuture.afterDone()
, consulting AbstractFuture.isCancelled()
and AbstractFuture.wasInterrupted()
as necessary. This ensures that the work is done even if the future is
cancelled without a call to cancel
, such as by calling setFuture(cancelledFuture)
.
cancel
in interface java.util.concurrent.Future<V>
cancel
in class AbstractFuture<V>
public boolean isCancelled()
isCancelled
in interface java.util.concurrent.Future<V>
isCancelled
in class AbstractFuture<V>
public boolean isDone()
isDone
in interface java.util.concurrent.Future<V>
isDone
in class AbstractFuture<V>
public V get() throws java.lang.InterruptedException, java.util.concurrent.ExecutionException
AbstractFuture
The default AbstractFuture
implementation throws InterruptedException
if the
current thread is interrupted during the call, even if the value is already available.
get
in interface java.util.concurrent.Future<V>
get
in class AbstractFuture<V>
java.lang.InterruptedException
java.util.concurrent.ExecutionException
public V get(long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException, java.util.concurrent.TimeoutException
AbstractFuture
The default AbstractFuture
implementation throws InterruptedException
if the
current thread is interrupted during the call, even if the value is already available.
get
in interface java.util.concurrent.Future<V>
get
in class AbstractFuture<V>
java.lang.InterruptedException
java.util.concurrent.ExecutionException
java.util.concurrent.TimeoutException
public java.lang.String toString()
toString
in class AbstractFuture<V>