Method call to Future.get() blocks. Is that really desirable?
Future
offers you method isDone()
which is not blocking and returns true if computation has completed, false otherwise.
Future.get()
is used to retrieve the result of computation.
You have a couple of options:
- call
isDone()
and if the result is ready ask for it by invokingget()
, notice how there is no blocking - block indefinitely with
get()
- block for specified timeout with
get(long timeout, TimeUnit unit)
The whole Future API
thing is there to have easy way obtaining values from threads executing parallel tasks. This can be done synchronously or asynchronously if you prefer, as described in bullets above.
UPDATE WITH CACHE EXAMPLE
Here is a cache implementation from Java Concurrency In Practice, an excellent use case for Future
.
- If the computation is already running, caller interested in result of computation will wait for computation to finish
- If the result is ready in the cache, caller will collect it
- if the result is not ready and computation has not started yet, caller will start computation and wrap result in
Future
for other callers.
This is all easily achieved with Future
API.
package net.jcip.examples;
import java.util.concurrent.*;
/**
* Memoizer
* <p/>
* Final implementation of Memoizer
*
* @author Brian Goetz and Tim Peierls
*/
public class Memoizer <A, V> implements Computable<A, V> {
private final ConcurrentMap<A, Future<V>> cache
= new ConcurrentHashMap<A, Future<V>>();
private final Computable<A, V> c;
public Memoizer(Computable<A, V> c) {
this.c = c;
}
public V compute(final A arg) throws InterruptedException {
while (true) {
Future<V> f = cache.get(arg);
// computation not started
if (f == null) {
Callable<V> eval = new Callable<V>() {
public V call() throws InterruptedException {
return c.compute(arg);
}
};
FutureTask<V> ft = new FutureTask<V>(eval);
f = cache.putIfAbsent(arg, ft);
// start computation if it's not started in the meantime
if (f == null) {
f = ft;
ft.run();
}
}
// get result if ready, otherwise block and wait
try {
return f.get();
} catch (CancellationException e) {
cache.remove(arg, f);
} catch (ExecutionException e) {
throw LaunderThrowable.launderThrowable(e.getCause());
}
}
}
}
Below is the snippet of the pseudo code. My question is- Does the below code not defeat the very notion of parallel asynchronous processing?
It all depends on your use case:
If you really want to block till you get the result, use blocking
get()
If you can wait for a specific period to know the status instead of infinite blocking duration, use
get()
with time-outIf you can continue without analysing the result immediately and inspect the result at future time, use CompletableFuture (java 8)
A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.
You can implement callback mechanism from your Runnable/Callable. Have a look at below SE question:
Java executors: how to be notified, without blocking, when a task completes?