CODEWITHSUNDEEP
javafuturecompletable-future
Novice
Novice

Reputation: 443

Execute a list of completable futures only if the previous one throws an exception

I have a list of completable futures and I would like to start with the first future and if there are any completion exceptions, I'd like to try the next future in the list and so on until I exhausted all of my futures. If any of the futures succeed, i'd like to stop there without using the next futures in the list. How do I accomplish this? So far, I have tried this:


for (SampleFutures future : getSampleFutures()) {

    try {
          return future.someMethod();
      } catch (Exception e) {
          log.error("An exception occurred, Will try the next future.", e);
      }
}

But when I was testing this method, I see that when something fails in the future completion exception is thrown and the next set of futures are not tried.

Edit:

This is how SampleFtures look like

public class SampleFutureA implements SampleFutures {

    @Override
    public CompletableFuture<SomeOject> someMethod() {
        return CompletableFuture
                .supplyAsync(() -> someOtherMethod())
                .thenApply( ()->anotherMethod())
                .exceptionally(ex -> exceptionHandler(ex));
    }

Upvotes: 0

Views: 516

Answers (1)

Didier L
Didier L

Reputation: 20579

This is the kind of issue for which I would recommend using EA Async as it provides a kind of async/await mecanism that makes it very easy to implement this:

Initialize async when your application starts: (you can also pre-process the application, read the documentation for details)

Async.init();

then use await() as follows:

for (SampleFutures future : getSampleFutures()) {
    try {
        return completedFuture(await(future.someMethod()));
    } catch (Exception e) {
        log.error("An exception occurred, Will try the next future.", e);
    }
}
throw new RuntimeException("All futures failed!");

However, if you cannot or do not want to use it, you can implement the same thing with a recursive asynchronous method:

private CompletableFuture<SomeObject> processNext(Iterator<SampleFutures> iterator) {
    if (iterator.hasNext()) {
        return iterator.next().someMethod()
                .handle((r, e) -> {
                    if (e != null) {
                        log.error("An exception occurred, Will try the next future.", e);
                        return processNext(iterator);
                    } else {
                        return completedFuture(r);
                    }
                }).thenCompose(c -> c);
    }
    CompletableFuture<SomeObject> allFailed = new CompletableFuture<>();
    allFailed.completeExceptionally(new RuntimeException("All futures failed!"));
    return allFailed;
}

that you call with

return processNext(getSampleFutures().iterator());

This method will call the first future, and only when it fails, it will recursively call itself aynchronously which will call the next ones.

We are unfortunately forced to implement it with hande() + thenCompose(c -> c) because there is no "compose" version of handle() and exceptionally(). So handle() returns a CompletableFuture<CompletableFuture<SampleObject>> and thenCompose() just unwraps it.

Upvotes: 1

Related Questions