https://www.nurkiewicz.com/2013/02/listenablefuture-in-guava.html
Technically
ListenableFuture extends Future interface by adding simple void addListener(Runnable listener, Executor executor)method. That's it. If you get a hold of
ListenableFuture you can register Runnable to be executed immediately when future in question completes. You must also supply Executor (ExecutorServiceextends it) that will be used to execute your listener - so that long-running listeners do not occupy your worker threads.ListeningExecutorService pool = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
for (final URL siteUrl : topSites) {
final ListenableFuture<String> future = pool.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return IOUtils.toString(siteUrl, StandardCharsets.UTF_8);
}
});
future.addListener(new Runnable() {
@Override
public void run() {
try {
final String contents = future.get();
//...process web site contents
} catch (InterruptedException e) {
log.error("Interrupted", e);
} catch (ExecutionException e) {
log.error("Exception in task", e.getCause());
}
}
}, MoreExecutors.sameThreadExecutor());
}
Finally notice MoreExecutors.sameThreadExecutor() being used. It's a handy abstraction which you can use every time some API wants to use an Executor/ExecutorService (presumably thread pool) while you are fine with using current thread. This is especially useful during unit testing - even if your production code uses asynchronous tasks, during tests you can run everything from the same thread. Futures.addCallback(future, new FutureCallback<String>() {
@Override
public void onSuccess(String contents) {
//...process web site contents
}
@Override
public void onFailure(Throwable throwable) {
log.error("Exception in task", throwable);
}
});
FutureCallback is a much simpler abstraction to work with, resolves future and does exception handling for you. Also you can still supply custom thread pool for listeners if you want. If you are stuck with some legacy API that still returns Future you may try JdkFutureAdapters.listenInPoolThread() which is an adapter converting plain Future<V> to ListenableFuture<V>. But keep in mind that once you start using addListener(), each such adapter will require one thread exclusively to work so this solution doesn't scale at all and you should avoid it.Future<String> future = //...
ListenableFuture<String> listenableFuture =
JdkFutureAdapters.listenInPoolThread(future);
http://codingjunkie.net/google-guava-concurrency-listenablefuture/
https://www.jesperdj.com/2015/09/21/listen-to-the-future-with-google-guava/
https://stackoverflow.com/questions/38744943/listenablefuture-vs-completablefuture
In other words... ListenableFuture is a well thought out clean interface, while CompletableFuture (and the CompletionStage interface since it exposes toCompletableFuture) is dangerous because it exposes complete methods. Yet another example of the not-very-well-thought-out garbage that we've come to expect from Oracle.
With CompletableFuture you can also register a callback for when the task is complete, but it is different from ListenableFuture in that it can be completed from any thread that wants it to complete.
CompletableFuture completableFuture = new CompletableFuture();
completableFuture.whenComplete(new BiConsumer() {
@Override
public void accept(Object o, Object o2) {
//handle complete
}
}); // complete the task
completableFuture.complete(new Object())
When a thread calls complete on the task, the value received from a call to get() is set with the parameter value if the task is not already completed.
