如何将代码转换为使用可完成未来？

Question

我以前有个可打电话的课

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

我曾经使用ExecutorService提交可调用。如何更改为使用CompletableFuture.supplyAsync？

以下代码无法编译

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

不存在变量U类型的实例，因此SampleTask符合供应商




Answer 1

由于完整未来：：供应同步期望供应商

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

Answer 2

< code>supplyAsync()需要一个< code >供应商

错误消息告诉您编译器已尝试查找用于U的类型，因此您的SampleTask"是"供应商

Java将隐式地将lambda“提升”为功能接口，例如Callable或Supplier。但它不会将功能接口视为可互换的——也就是说，不能在需要供应商的地方使用Callable。

您可以就地制作合适的λ：

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

请注意，如果SimpleTask的call（）:

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

< code>SimpleTask恰好实现< code>Callable这一事实与上面的代码无关。

如果您希望它与任意的< code >可调用一起工作，或者如果您将< code>task声明为< code >可调用:

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

...然后，您将收到有关未捕获异常的编译器错误。您的 lambda 需要捕获异常并对其进行处理（可能作为未经检查的异常重新引发，如其他答案中所述）。

或者您可以让< code>SampleTask实现< code>Supplier

lambdas的部分动机是写像可调用这样的东西太冗长了。因此，您可能会省略中间类，直接转到：

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

这也适用于更复杂的供应商：

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

Answer 3

匿名用户

对于你所写的可调用，你可以简单地使用可完成未来.supply异步（（） -

但是，如果您有一个现有的< code>Callable，那么将它与< code>CompletableFuture一起使用就不那么直接了，因为Callable可能会引发检查过的异常。

您可以使用临时供应商来捕获异常并将其包装在未检查的异常中重新抛出，如

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

使用特定类型< code>CompletionException而不是< code>RuntimeException的任意子类型，可以避免在调用< code>join()时获得包装实际异常的< code>CompletionException包装运行时异常。

不过，在将异常处理程序链接到CompletableFuture时，您会注意到包装。此外，join（）抛出的CompletionException子句中创建的，因此包含一些后台线程的堆栈跟踪，而不是调用0.05的线程。换句话说，该行为仍然不同于抛出异常的供应商。

使用稍微复杂一点的

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;
}

你会得到一个可完成的未来，它的行为与supplyAsync完全相同，没有其他包装器异常类型，即如果你使用

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

< code>t将是由< code>Callable引发的确切异常，即使它是已检查的异常。也就是< code>callAsync(task)。join()将生成一个< code>CompletionException，其中包含< code>join()调用方的堆栈跟踪，直接包装由< code>Callable在异常情况下引发的异常，就像< code>Supplier或< code>runAsync一样。