CompletableFuture——快速失败的聚合未来

Question

我一直在使用CompletableFuture.allOf（...）助手来创建聚合期货，只有当它们的复合期货被标记为完成时才会成为“完成”，即：

CompletableFuture<?> future1 = new CompletableFuture<>();
CompletableFuture<?> future2 = new CompletableFuture<>();
CompletableFuture<?> future3 = new CompletableFuture<>();

CompletableFuture<?> future = CompletableFuture.allOf(future1, future2, future3);

我想对这一功能稍作改动，在以下情况下，总的未来市场是完整的：

• 所有期货均已成功完成或

在后一种情况下，总期货应立即完成（例外），而不必等待其他期货完成，即快速失败。

对比CompletableFuture来说明这一点。allOf（…） 考虑一下：

// First future completed, gotta wait for the rest of them...
future1.complete(null);
System.out.println("Future1 Complete, aggregate status: " + future.isDone());

// Second feature was erroneous! I'd like the aggregate to now be completed with failure
future2.completeExceptionally(new Exception());
System.out.println("Future2 Complete, aggregate status: " + future.isDone());

// Finally complete the third future, that will mark the aggregate as done
future3.complete(null);
System.out.println("Future3 Complete, aggregate status: " + future.isDone());

使用allOf（…） ，此代码生成：

Future1 Complete, aggregate status: false
Future2 Complete, aggregate status: false
Future3 Complete, aggregate status: true

而我的替代聚合实现在Feature2完成后会返回“true”，因为这是一个例外。

我在Java标准库中找不到任何可以帮助我实现这一点的UTIL，这让我感觉很奇怪。。。考虑到这是一个相对普通的用例。

查看CompletableFuture的实现。allOf（…） 很明显，这些场景背后的逻辑相当复杂。我讨厌自己写这篇文章，我想知道是否有其他选择？




Answer 1

您可以通过创建allOf和anyOf，然后将它们组合成第二个anyOf来做到这一点。

Answer 2

虽然在语法上不如CompletableFuture.allOf（...）方法，但似乎thenCompose（...）可以提供解决方案：

CompletableFuture<?> future = future1.thenCompose((f) -> future2).thenCompose((f) -> future3);

这将产生所需的：

Future1 Complete, aggregate status: false
Future2 Complete, aggregate status: true
Future3 Complete, aggregate status: true

这可以包装在一个帮助方法中，该方法将为调用者提供一些语法细节：

private static CompletableFuture<?> composed(CompletableFuture<?> ... futures) {

    // Complete when ALL the underlying futures are completed
    CompletableFuture<?> allComplete = CompletableFuture.allOf(futures);

    // Complete when ANY of the underlying futures are exceptional
    CompletableFuture<?> anyException = new CompletableFuture<>();
    for (CompletableFuture<?> completableFuture : futures) {
        completableFuture.exceptionally((t) -> {
            anyException.completeExceptionally(t);
            return null;
        });
    }

    // Complete when either of the above are satisfied
    return CompletableFuture.anyOf(allComplete, anyException);
}

考虑到：

CompletableFuture<?> future = composed(future1, future2, future3);