How to convert the code to use CompletableFuture?

Question

I used to have a callable class

class SampleTask implements Callable<Double> {
  @Override
  public Double call() throws Exception {
    return 0d;
  }
}

I used to use ExecutorService to submit the Callable. How to change to use CompletableFuture.supplyAsync?

The following code cannot compile

SampleTask task = new SampleTask();
CompletableFuture.supplyAsync(task);

No instance of type of variable U exists so that SampleTask conforms to Supplier

Answer 1

For your callable as written, you could simply use CompletableFuture.supplyAsync(() -> 0d);.

If, however, you have an existing Callable, using it with CompletableFuture is not so straight-forward due to the checked exceptions that a callable might throw.

You may use an ad-hoc Supplier which catches exceptions and re-throws it wrapped in an unchecked exception like

CompletableFuture.supplyAsync(() -> {
    try { return callable.call(); }
    catch(Exception e) { throw new CompletionException(e); }
})

Using the specific type CompletionException instead of an arbitrary subtype of RuntimeException avoids getting a CompletionException wrapping a runtime exception wrapping the actual exception when calling join().

Still, you’ll notice the wrapping when chaining an exception handler to the CompletableFuture. Also, the CompletionException thrown by join() will be the one created in the catch clause, hence contain the stack trace of some background thread rather than the thread calling join(). In other words, the behavior still differs from a Supplier that throws an exception.

Using the slightly more complicated

public static <R> CompletableFuture<R> callAsync(Callable<R> callable) {
    CompletableFuture<R> cf = new CompletableFuture<>();
    CompletableFuture.runAsync(() -> {
        try { cf.complete(callable.call()); }
        catch(Throwable ex) { cf.completeExceptionally(ex); }
    });
    return cf;
}

you get a CompletableFuture which behaves exactly like supplyAsync, without additional wrapper exception types, i.e. if you use

callAsync(task).exceptionally(t -> {
    t.printStackTrace();
    return 42.0;
})

t will be the exact exception thrown by the Callable, if any, even if it is a checked exception. Also callAsync(task).join() would produce a CompletionException with a stack trace of the caller of join() directly wrapping the exception thrown by the Callable in the exceptional case, exactly like with the Supplier or like with runAsync.

Answer 2

supplyAsync() expects a Supplier<U> and you are giving it a Callable.

The error message is telling you that the compiler has tried to find a type to use for U such that your SampleTask "is a" Supplier<U>, but it can't find one.

Java will implicitly "promote" a lambda to a functional interface such as Callable or Supplier. But it won't treat functional interfaces as interchangeable -- that is, you can't use a Callable where a Supplier is expected.

You can make a suitable lambda in-place:

SimpleTask task = new SimpleTask();
CompletableFuture.supplyAsync(() -> task.call());

Note that this works if SimpleTask's call() is:

 public Double call() {  // note no exception declared
    return 0d;   
 }

The fact that SimpleTask happens to implement Callable is not relevant to the code above.

---

If you want this to work with an arbitrary Callable, or if you declare task as a Callable:

Callable callable = new SimpleTask();
CompletableFuture.supplyAsync(() -> callable.call());

... then you will get a compiler error about the uncaught exception. Your lambda will need to catch the exception and handle it (perhaps rethrowing as an unchecked exception, as described in other answers).

---

Or you could make SampleTask implement Supplier<Double>.

---

Part of the motivation for lambdas is that writing things like Callable was too verbose. So you might well leave out the intermediate class and go directly for:

CompleteableFuture<Double> future = CompletableFuture.supplyAsync(() -> 0d);

This applies for more complicated suppliers too:

CompleteableFuture<Double> future = CompletableFuture.supplyAsync(() -> {
     Foo foo = slowQuery();
     return transformToDouble(foo);
});

Answer 3

Since CompleteableFuture::supplyAsync expects a Supplier<Double> and not Callable<Double> you should go with:

Callable<Double> task = new SampleTask();
CompletableFuture.supplyAsync(() -> {
  try {
    return task.call();
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
});

Answer 4

I had this come up recently and used Vavr to solve it (was already using it for other things, too), and it worked out great for me:

CompletableFuture.supplyAsync( () -> Try.ofCallable( callable ).get() )

Or to get a Supplier of that CompletableFuture:

() -> CompletableFuture.supplyAsync( () -> Try.ofCallable( callable ).get() )

In all cases I tested this returned exactly and threw exactly what the callable itself did.