为什么即使我不调用 get() 或 join()，这个 CompletableFuture 也能工作？

Question

我在学习CompletableFuture 时遇到了一个问题。 get()/join() 方法是阻塞调用。如果我不打电话给他们怎么办？

此代码调用get():

// Case 1 - Use get()
CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1_000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Hello");
}).get();
System.out.println("World!");

Thread.sleep(5_000L); // Don't finish the main thread

输出：

Hello
World!

这段代码既不调用get()也不调用join()：

// Case 2 - Don't use get()
CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1_000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Hello");
});
System.out.println("World!");

Thread.sleep(5_000L); // For don't finish main thread

输出：

World!
Hello

我不知道为什么案例 2 的可运行块正在工作。

Answer 1

CompletableFuture 的整个想法是它们会立即被安排启动（尽管您无法可靠地判断它们将在哪个线程中执行），并且当您到达 get 或 join 时，结果可能已经准备好，即：CompletableFuture 可能已经完成。在内部，一旦管道中的某个阶段准备就绪，该特定的CompletableFuture 将被设置为完成。例如：

String result = 
   CompletableFuture.supplyAsync(() -> "ab")
                    .thenApply(String::toUpperCase)
                    .thenApply(x -> x.substring(1))
                    .join();

与以下内容相同：

CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "ab");
CompletableFuture<String> cf2 = cf1.thenApply(String::toUpperCase);
CompletableFuture<String> cf3 = cf2.thenApply(x -> x.substring(1));
String result = cf3.join();

当您实际调用join 时，cf3 可能已经完成。 get 和 join 只是 block 直到所有阶段都完成，它不会触发计算；立即安排计算。

---

一个小的补充是您可以完成CompletableFuture，而无需等待管道的执行完成：如complete、completeExceptionally、obtrudeValue（即使它已经完成，也可以设置它） 、obtrudeException 或 cancel。这是一个有趣的例子：

 public static void main(String[] args) {
    CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
        System.out.println("started work");
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(5));
        System.out.println("done work");
        return "a";
    });

    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
    cf.complete("b");
    System.out.println(cf.join());
}

这将输出：

started work
b

所以即使工作开始了，最终的值是b，而不是a。

Answer 2

我不知道为什么 case2 的 Runnable 块有效。

没有理由不工作。

runAsync(...) 方法表示异步执行任务。假设应用程序不会提前结束，那么任务最终会完成，无论您是否等待它完成。

CompletableFuture 提供了多种等待任务完成的方式。但是在您的示例中，您没有将其用于此目的。相反，您的 main 方法中的 Thread.sleep(...) 调用具有相同的效果；即等待任务已经（可能）完成的时间足够长。所以"Hello"在"World"之前输出。

重申一下，get() 调用不会导致任务发生。相反，它等待它已经发生。

---

使用sleep 等待事件（例如完成任务）发生是个坏主意：

1. 睡眠并不能说明事件是否发生！
2. 您通常不知道事件发生需要多长时间，也不知道要睡多久。
3. 如果您睡得太久，您就有了“死时间”（见下文）。
4. 如果您睡眠时间不够长，则该事件可能尚未发生。所以你需要一次又一次地测试和睡觉，然后......

即使在这个例子中，理论上也有可能¹ main 中的 sleep 在任务中的 sleep 之前完成。

基本上，CompletableFuture 的目的是提供一种有效的方式来等待任务完成并交付结果。你应该使用它...

为了说明。您的应用程序在输出 "Hello" 和 "World!" 之间等待（并浪费）约 4 秒。如果您按预期使用CompletableFuture，则不会有那 4 秒的“死区时间”。

---

^{1 - 例如，某些外部代理可能能够选择性地“暂停”正在运行任务的线程。可以通过设置断点来完成...}

Answer 3

第二种情况是“working”，因为你让主线程休眠了足够长的时间（5 秒）。工作是在引号之间，因为它并没有真正工作，只是完成了。我在这里假设代码应该输出 Hello World! 以便被认为是“正常工作”。

---

在这两种情况下，在主线程结束时尝试使用此睡眠时间的相同代码：

Thread.sleep(100);

1。第一个的行为方式相同，因为 get 操作阻塞了主线程。事实上，对于第一种情况，你甚至不需要最后的睡眠时间。

输出：Hello World!

---

2。第二种情况不会输出Hello，因为没有人告诉主线程：“嘿，等待这个完成”。这就是get() 所做的：阻止调用者以等待任务完成。没有它，并在最后设置低睡眠时间，runnable 被调用，但在主线程停止之前无法完成其工作。

输出：World!

---

这也是为什么在第一种情况下写Hello World!（首先是runnable的输出，然后是main的一个-意味着主线程被阻塞直到get()返回），而第二个有阅读障碍的微妙迹象：World Hello!

但这不是阅读障碍，它只是执行它被告知的内容。在第二种情况下，会发生这种情况：

1. 可运行对象被称为。

2. 主线程继续其进程，打印（“世界！）”

3. Sleep 时间设置：可运行 1 秒 / 主 5 秒。 （runnable 的 sleep 也可以在第二步执行，但我把它放在这里是为了澄清行为）

4. 可运行任务在 1 秒后打印 ("Hello")，CompletableFuture 完成。

5. 5 秒过去了，主线程停止。

所以你的 runnable 可以打印 Hello 因为它能够在这 5 秒超时之间执行命令。

World! . . . . . .(1)Hello. . . . . . . . . . .(5)[END]

如果您将最后 5 秒的超时时间减少到 0.5 秒，例如，您会得到

World!. . (0.5)[END]