java ploteablefuture.allof（）。wercomplete（）有多个异常

Question

Java官方文档中的问题

，它说

公共静态完整future＆lt; void＆gt; allof（pountableFuture＆lt;？＆gt; ... cfs）

返回一个新的可完整图案，当所有给定的完整图完整完成后，该图已完成。如果给定的可完成的任何一个特殊的未完成，则返回的完整future也可以这样做，而将此例外作为其原因。

。

当多个给定的可完成的图完全完成时，文档未指定情况。例如，在以下代码段中，如果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);
            }
        })

---

我的实验1

创建一个完整的future signal_1和signal_2，两者都非常快地完成。输出显示signal_1将传递到.whencomplete（）作为异常原因。

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

我的实验2

在sigral_1中添加了3秒的睡眠，因此signal_1应在 sigral_2之后完成signal_1。但是，输出仍然显示signal_1将传递到.whencomplete（）作为异常原因。

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在所有平台和性能上都优先考虑相似/相同的行为，因此选择不指定执行的某些方面，使他们能够忠于该诺言，同时仍然获得特定平台带来的优化好处。

另一个例子是，何时将行为统一到特定行动的行为当前不可行。如果我不得不猜测，这很可能是Java实际上在做的。在某些情况下，Java将设计一个具有电位某些功能的组件，但将停止实际定义和实施它。这通常是在构建完整的解决方案的情况下要做的，这是比其他原因更大的努力。具有讽刺意味的是，完整的未来本身就是一个很好的例子。 Java 5引入了未来，但仅作为通用功能的接口。完整的未来，在Java 8中出现的隐含性，后来充实并定义了Java 5接口中剩下的所有未指定的行为。

最后，如果选择指定的行为扼杀了可能的实现的灵活性，他们可能会避免定义指定的行为。当前，您显示的方法没有关于 的任何指定行为。这允许任何后来扩展完整未来的类都能够为自己指定该行为，同时仍保持。如果您还不知道，LSP说，如果子类扩展父班，那么该子类必须遵循父班的所有规则。结果，如果类的规则（指定的行为）过于限制，那么您可以防止本类的将来的实现/扩展能够在不破坏LSP的情况下运行。可以完成一些可完整图的扩展，使您可以准确定义调用该方法时会抛出哪种类型的异常。但这就是重点 - 它们是扩展，您可以选择 选择 。如果他们为您定义它，那么除非您自己实施，否则您会坚持使用它，或者您进入语言标准库。