Java CompletableFutures：不加入/获取是否可以接受？

不返回或加入一个完整的未来是正确的吗

也就是说，这个代码是正确的吗

void noJoin() {
   CompletableFuture<Void> cfa = CompletableFuture
                                   .supplyAsync(() -> "a")
                                   .thenAccept(this::someSideEffect);

   CompletableFuture<Void> cfb = CompletableFuture
                                   .supplyAsync(() -> "b")
                                   .thenAccept(this::someSideEffect);
}

另一方面，如果它真的很重要，我们需要加入或返回两个期货，通过组合它们（可以是串行组合，也可以是并行组合或allOf），然后加入组合的期货或将其返回给调用方

通过加入，我们阻止并抛出一个异常，如果其中一个未来是异常的；或者更好的方法是，通过返回一个未来，我们保持异步，同时确保调用方获得一个包含任何异常结果的未来：

Future<Void> returnBothAsync() {

       CompletableFuture<Void> cfa = CompletableFuture
                                       .supplyAsync(() -> "a")
                                       .thenAccept(this::someSideEffect);

       CompletableFuture<Void> cfb = CompletableFuture
                                       .supplyAsync(() -> "b")
                                       .thenAccept(this::someSideEffect);

       return CompletableFuture.allOf(cfa, cfb);
}

Future returnBothAsync（）{
CompletableFuture cfa=CompletableFuture
.SupplySync（（）->“a”）
.然后接受（这个：：某种副作用）；
CompletableFuture cfb=CompletableFuture
.SupplySync（（）->“b”）
.然后接受（这个：：某种副作用）；
返回CompletableFuture.allOf（cfa、cfb）；
}

或

void joinBothBlock（）{
CompletableFuture cfa=CompletableFuture
.SupplySync（（）->“a”）
.然后接受（这个：：某种副作用）；
CompletableFuture cfb=CompletableFuture
.SupplySync（（）->“b”）
.然后接受（这个：：某种副作用）；
CompletableFuture.allOf（cfa，cfb）.get（50L，TimeUnit.ms）；
}

我认为这是事实，即使我们安排处理所有例外情况：

void noJoin() {
   CompletableFuture<Void> cfa = CompletableFuture
                                   .supplyAsync(() -> "a")
                                   .thenAccept(this::someSideEffect)
                                   .exceptionally(e -> {
                                         Logger.log(e);
                                         return DEFAULT;
                                   });

   CompletableFuture<Void> cfb = CompletableFuture
                                   .supplyAsync(() -> "b")
                                   .thenAccept(this::someSideEffect);
}

void noJoin（）{
CompletableFuture cfa=CompletableFuture
.SupplySync（（）->“a”）
.thenAccept（此：：someSideEffect）
.例外情况（e->{
Logger.log（e）；
返回默认值；
});
CompletableFuture cfb=CompletableFuture
.SupplySync（（）->“b”）
.然后接受（这个：：某种副作用）；
}

因为即使例外情况被处理了/“不可能发生”，我们仍然不知道未来是否已经完成

---

或者我错了，在某些情况下，

noJoin

中这样的代码是正确的？

这并不是对您问题的完整回答。它可能取决于确切的用例，以能够告诉如何处理

CompletableFuture

及其结果

如果您选择不等待

CompletableFuture

s的结果，则可能需要确保使用的执行器完成所有任务。在您的情况下，使用过的遗嘱执行人的文件上写着：

[…]但是，此池和任何正在进行的处理将在program System.exit（int）时自动终止。任何依赖异步任务处理在程序终止之前完成的程序都应该在退出之前调用commonPool（）

---

您实际上是在寻找放弃completablefuture实例不正确的示例/案例吗？您知道当

this:：someSideEffect

产生副作用时，异步操作已完成。

void joinBothBlocking() {

       CompletableFuture<Void> cfa = CompletableFuture
                                       .supplyAsync(() -> "a")
                                       .thenAccept(this::someSideEffect);

       CompletableFuture<Void> cfb = CompletableFuture
                                       .supplyAsync(() -> "b")
                                       .thenAccept(this::someSideEffect);

       CompletableFuture.allOf(cfa, cfb).get(50L, TimeUnit.MILLISECONDS);
}

void noJoin() {
   CompletableFuture<Void> cfa = CompletableFuture
                                   .supplyAsync(() -> "a")
                                   .thenAccept(this::someSideEffect)
                                   .exceptionally(e -> {
                                         Logger.log(e);
                                         return DEFAULT;
                                   });

   CompletableFuture<Void> cfb = CompletableFuture
                                   .supplyAsync(() -> "b")
                                   .thenAccept(this::someSideEffect);
}