@GwtCompatible public final class SettableFuture<V> extends AbstractFuture<V>
ListenableFuture
whose result may be set by a
set(Object)
,
setException(Throwable)
or
setFuture(ListenableFuture)
call. It may also be cancelled.
ValueFuture
)
Modifier and Type | Method and Description |
---|---|
void |
addListener(Runnable
Registers a listener to be
run on the given executor.
|
static <V> SettableFuture |
create()
Creates a new
SettableFuture in the default state.
|
V |
get()
|
V |
get(long timeout, TimeUnit
|
boolean |
isCancelled()
|
boolean |
isDone()
|
boolean |
set(V value)
Sets the result of this
Future unless this
Future has already been cancelled or set (including
set asynchronously).
|
boolean |
setException(Throwable
Sets the failed result of this
Future unless this
Future has already been cancelled or set (including
set asynchronously).
|
boolean |
setFuture(ListenableFuture
Sets the result of this
Future to match the supplied input
Future once the supplied
Future is done, unless this
Future has already been cancelled or set (including "set asynchronously," defined below).
|
cancel, interruptTask, wasInterrupted
public static <V> SettableFuture<V> create()
SettableFuture
in the default state.
public boolean set(V value)
AbstractFuture
Future
unless this
Future
has already been cancelled or set (including
set asynchronously). When a call to this method returns, the
Future
is guaranteed to be
done
only if the call was accepted (in which case it returns
true
). If it returns
false
, the
Future
may have previously been set asynchronously, in which case its result may not be known yet. That result, though not yet known, cannot by overridden by a call to a
set*
method, only by a call to
AbstractFuture.cancel(boolean)
.
set
in class
AbstractFuture<V>
value
- the value to be used as the result
Future
public boolean setException(Throwablethrowable)
AbstractFuture
Future
unless this
Future
has already been cancelled or set (including
set asynchronously). When a call to this method returns, the
Future
is guaranteed to be
done
only if the call was accepted (in which case it returns
true
). If it returns
false
, the
Future
may have previously been set asynchronously, in which case its result may not be known yet. That result, though not yet known, cannot by overridden by a call to a
set*
method, only by a call to
AbstractFuture.cancel(boolean)
.
setException
in class
AbstractFuture<V>
throwable
- the exception to be used as the failed result
Future
@Beta public boolean setFuture(ListenableFuture<? extends V> future)
AbstractFuture
Future
to match the supplied input
Future
once the supplied
Future
is done, unless this
Future
has already been cancelled or set (including "set asynchronously," defined below).
If the supplied future is done when this method is called and the call is accepted, then this future is guaranteed to have been completed with the supplied future by the time this method returns. If the supplied future is not done and the call is accepted, then the future will be set asynchronously. Note that such a result, though not yet known, cannot by overridden by a call to a set*
method, only by a call to AbstractFuture
.
If the call setFuture(delegate)
is accepted and this Future
is later cancelled, cancellation will be propagated to delegate
. Additionally, any call to setFuture
after any cancellation will propagate cancellation to the supplied Future
.
setFuture
in class
AbstractFuture<V>
future
- the future to delegate to
Future
was not previously cancelled or set.
public final V get() throws InterruptedException, ExecutionException
AbstractFuture
The default AbstractFuture
implementation throws InterruptedException
if the current thread is interrupted before or during the call, even if the value is already available.
get
in interface
Future<V>
get
in class
AbstractFuture<V>
InterruptedException
- if the current thread was interrupted before or during the call (optional but recommended).
ExecutionException
public final V get(long timeout, TimeUnitunit) throws InterruptedException , ExecutionException , TimeoutException
AbstractFuture
The default AbstractFuture
implementation throws InterruptedException
if the current thread is interrupted before or during the call, even if the value is already available.
get
in interface
Future<V>
get
in class
AbstractFuture<V>
InterruptedException
- if the current thread was interrupted before or during the call (optional but recommended).
ExecutionException
TimeoutException
public final boolean isDone()
public final boolean isCancelled()
public final void addListener(Runnablelistener, 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
. 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.
addListener
in interface
ListenableFuture<V>
addListener
in class
AbstractFuture<V>
listener
- the listener to run when the computation is complete
executor
- the executor to run the listener in