T - The result object type returned by this futurepublic class ImmediateResultListenableFuture<T>
extends java.lang.Object
ListenableFuture that will immediately return a result.
Meaning listeners added will immediately be ran/executed, FutureCallback's will
immediately get called with the result provided, and get() calls will never block.ListenableFuture.ListenerOptimizationStrategy| Modifier and Type | Field and Description |
|---|---|
static ImmediateResultListenableFuture<java.lang.Boolean> |
BOOLEAN_FALSE_RESULT
Static instance of
ImmediateResultListenableFuture which provides a Boolean
in the false state as the result. |
static ImmediateResultListenableFuture<java.lang.Boolean> |
BOOLEAN_TRUE_RESULT
Static instance of
ImmediateResultListenableFuture which provides a Boolean
in the true state as the result. |
static ImmediateResultListenableFuture<?> |
NULL_RESULT
Static instance of
ImmediateResultListenableFuture which provides a null
result. |
| Constructor and Description |
|---|
ImmediateResultListenableFuture(T result)
Constructs a completed future that will return the provided result.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addCallback(FutureCallback<? super T> callback)
Add a
FutureCallback to be called once the future has completed. |
void |
addCallback(FutureCallback<? super T> callback,
java.util.concurrent.Executor executor,
ListenableFuture.ListenerOptimizationStrategy optimize)
Add a
FutureCallback to be called once the future has completed. |
void |
addListener(java.lang.Runnable listener)
Add a listener to be called once the future has completed.
|
void |
addListener(java.lang.Runnable listener,
java.util.concurrent.Executor executor,
ListenableFuture.ListenerOptimizationStrategy optimize)
Add a listener to be called once the future has completed.
|
boolean |
cancel(boolean mayInterruptIfRunning)
This has no effect in this implementation, as this future can not be canceled.
|
T |
get() |
T |
get(long timeout,
java.util.concurrent.TimeUnit unit) |
boolean |
isCancelled() |
boolean |
isDone() |
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitaddCallback, addListener, flatMap, flatMap, flatMap, map, map, mappublic static final ImmediateResultListenableFuture<?> NULL_RESULT
ImmediateResultListenableFuture which provides a null
result. Since this is a common case this can avoid GC overhead. If you want to get this in
any generic type use FutureUtils.immediateResultFuture(Object), which when provided a
null will always return this static instance.public static final ImmediateResultListenableFuture<java.lang.Boolean> BOOLEAN_TRUE_RESULT
ImmediateResultListenableFuture which provides a Boolean
in the true state as the result.public static final ImmediateResultListenableFuture<java.lang.Boolean> BOOLEAN_FALSE_RESULT
ImmediateResultListenableFuture which provides a Boolean
in the false state as the result.public ImmediateResultListenableFuture(T result)
result - Result that is returned by futurepublic void addCallback(FutureCallback<? super T> callback)
ListenableFutureFutureCallback to be called once the future has completed. If the future has
already finished, this will be called immediately.
The callback from this call will execute on the same thread the result was produced on, or on the adding thread if the future is already complete. If the callback has high complexity, consider passing an executor in for it to be called on.
callback - to be invoked when the computation is completepublic void addCallback(FutureCallback<? super T> callback, java.util.concurrent.Executor executor, ListenableFuture.ListenerOptimizationStrategy optimize)
ListenableFutureFutureCallback to be called once the future has completed. If the future has
already finished, this will be called immediately.
If the provided Executor is null, the callback will execute on the thread which
computed the original future (once it is done). If the future has already completed, the
callback will execute immediately on the thread which is adding the callback.
Caution should be used when choosing to optimize the listener execution. If the listener is
complex, or wanting to be run concurrent, this optimization could prevent that. In addition
it will prevent other listeners from potentially being invoked until it completes. However
if the listener is small / fast, this can provide significant performance gains. It should
also be known that not all ListenableFuture implementations may be able to do such an
optimization. Please see ListenableFuture.ListenerOptimizationStrategy javadocs for more specific
details of what optimizations are available.
callback - to be invoked when the computation is completeexecutor - Executor the callback should be ran on, or nulloptimize - true to avoid listener queuing for execution if already on the desired poolpublic T get()
public T get(long timeout, java.util.concurrent.TimeUnit unit)
public boolean isDone()
isDone in interface java.util.concurrent.Future<T>public void addListener(java.lang.Runnable listener)
ListenableFuture
The listener from this call will execute on the same thread the result was produced on, or on
the adding thread if the future is already complete. If the runnable has high complexity,
consider using ListenableFuture.addListener(Runnable, Executor).
addListener in interface ListenableFuture<T>listener - the listener to run when the computation is completepublic void addListener(java.lang.Runnable listener,
java.util.concurrent.Executor executor,
ListenableFuture.ListenerOptimizationStrategy optimize)
ListenableFuture
If the provided Executor is null, the listener will execute on the thread which
computed the original future (once it is done). If the future has already completed, the
listener will execute immediately on the thread which is adding the listener.
Caution should be used when choosing to optimize the listener execution. If the listener is
complex, or wanting to be run concurrent, this optimization could prevent that. In addition
it will prevent other listeners from potentially being invoked until it completes. However
if the listener is small / fast, this can provide significant performance gains. It should
also be known that not all ListenableFuture implementations may be able to do such an
optimization. Please see ListenableFuture.ListenerOptimizationStrategy javadocs for more specific
details of what optimizations are available.
addListener in interface ListenableFuture<T>listener - the listener to run when the computation is completeexecutor - Executor the listener should be ran on, or nulloptimize - true to avoid listener queuing for execution if already on the desired poolpublic boolean cancel(boolean mayInterruptIfRunning)
cancel in interface java.util.concurrent.Future<T>mayInterruptIfRunning - will be ignoredfalse, as this future can't be canceledpublic boolean isCancelled()
isCancelled in interface java.util.concurrent.Future<T>