JavaCompletableFuture.allOf（）. when完成（）有多个例外

Question

在Java官方文档中，它说

公共静态可完成未来

当所有给定的CompletableFutures完成时，返回一个新的CompletableFuture。如果任何给定的CompletableFutures异常完成，则返回的CompletableFuture也会异常完成，CompletionException将此异常作为其原因。

该文档没有指定多个给定的ComppletableFutures异常完成的情况。例如，在下面的代码片段中，如果 c1、c2、c3 都异常完成，异常及其原因是什么？

CompletableFuture.allOf(c1, c2, c3)
        .whenComplete((result, exception) -> {
            if (exception != null) {
                System.out.println("exception occurs");
                System.err.println(exception);
            } else {
                System.out.println("no exception, got result: " + result);
            }
        })

创建一个完整的Futuresignal_1和signal_2，它们都完成得非常快。输出显示signal_1被传递给. when完成（）作为异常的原因。

package com.company;

import java.util.concurrent.*;

public class Main {

    private static void runTasks(int i) {
        System.out.printf("-- input: %s --%n", i);

        CompletableFuture<Void> signal_1 = new CompletableFuture<>();
        signal_1.completeExceptionally(new RuntimeException("Oh noes!"));

        CompletableFuture<Integer> signal_2 = CompletableFuture.supplyAsync(() -> 16 / i);

        CompletableFuture.allOf(signal_1, signal_2)
                .thenApplyAsync(justVoid -> {
                     final int num = signal_2.join();
                     System.out.println(num);
                     return num;
                })
                .whenComplete((result, exception) -> {
                    if (exception != null) {
                        System.out.println("exception occurs");
                        System.err.println(exception);
                    } else {
                        System.out.println("no exception, got result: " + result);
                    }
                })
                .thenApplyAsync(input -> input * 3)
                .thenAccept(System.out::println);

    }

    public static void main(String[] args) {
        runTasks(0);
    }

}

-- input: 0 --
exception occurs
java.util.concurrent.CompletionException: java.lang.RuntimeException: Oh noes!

Process finished with exit code 0

在signal_1异常完成之前添加了3秒的睡眠，因此signal_1应该在signal_2之后完成。但是，输出仍然显示signal_1作为异常原因传递给. when完成（）。

package com.company;

import java.util.concurrent.*;

public class Main {

    static ExecutorService customExecutorService = Executors.newSingleThreadExecutor();

    private static void runTasks(int i) {
        System.out.printf("-- input: %s --%n", i);

        CompletableFuture<Void> signal_1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            throw new RuntimeException("Oh noes!");
        }, customExecutorService);

        CompletableFuture<Integer> signal_2 = CompletableFuture.supplyAsync(() -> 16 / i);

        CompletableFuture.allOf(signal_1, signal_2)
                .thenApplyAsync(justVoid -> {
                     final int num = signal_2.join();
                     System.out.println(num);
                     return num;
                })
                .whenComplete((result, exception) -> {
                    if (exception != null) {
                        System.out.println("exception occurs");
                        System.err.println(exception);
                    } else {
                        System.out.println("no exception, got result: " + result);
                    }
                })
                .thenApplyAsync(input -> input * 3)
                .thenAccept(System.out::println);

    }

    public static void main(String[] args) {
        runTasks(0);
        customExecutorService.shutdown();
    }

}

-- input: 0 --
exception occurs
java.util.concurrent.CompletionException: java.lang.RuntimeException: Oh noes!

Process finished with exit code 0




Answer 1

这在很大程度上是VGR在评论中所说的重复，但这是一个重要的经验法则，值得全面阐述。

在Java中，有一个重要的概念叫做“未指定行为”。简而言之，如果文档没有明确定义在特定场景中发生的情况，那么实现可以自由地在合理范围内和显式定义的其他规则的范围内执行它选择的任何内容。这很重要，因为有几种不同的表现形式。

首先，结果可能是平台特定的。对于某些机器，保留未定义的行为允许进行一些特殊优化，这些优化仍然会返回“正确”的结果。而且，由于Java优先考虑所有平台上的相似/相同行为以及性能，选择不指定执行的某些方面可以让它们信守promise，同时仍能获得特定平台带来的优化好处。

另一个例子是，将行为统一为特定行为的行为目前不可行。如果我不得不猜测，这很可能是Java实际上正在做的事情。在某些情况下，Java将设计一个具有某些功能潜力的组件，但不会实际定义和实现它。这通常是在构建一个完整的解决方案将比它的价值更多的情况下完成的，以及其他原因。具有讽刺意味的是，CompletableFuture本身就是一个很好的例子。Java 5引入了Future，但只是作为一个具有通用功能的接口。CompletableFuture是Java 8中出现的概念，后来充实并定义了Java 5接口遗留下来的所有未指定的行为。

最后，如果选择特定行为会扼杀可能实现的灵活性，他们可能会避免定义特定行为。目前，您展示的方法没有任何指定的行为，关于未来失败时将引发哪个异常。这允许以后扩展CompletableFuture的任何类能够为自己指定该行为，同时仍保持Liskov的替换原则。如果您还不知道，LSP说如果子类扩展父类，则该子类必须遵循父类的所有规则。因此，如果类的规则（指定的行为）过于严格，则会阻止该类的未来实现/扩展在不破坏LSP的情况下运行。CompletableFuture可能有一些扩展，允许您精确定义调用该方法时引发的异常类型。但这就是问题所在-它们是可以选择加入的扩展。如果它们为您定义了它，那么除非您自己实现它，或者您超出了语言标准库，否则您将无法使用它。