一个分支早就失败，allOf 为什么还没有结束？

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;

public final class Main {
    private static int checks;
    private static void check(boolean ok, String message) {
        checks++;
        if (!ok) throw new AssertionError(message);
    }
    private static Throwable failureOf(CompletableFuture<?> future) {
        try {
            future.join();
            throw new AssertionError("Expected failure");
        } catch (CompletionException failure) {
            return failure.getCause();
        }
    }
    private static String outcome(String name, String value, Throwable error) {
        return error == null ? name + ":OK:" + value
                : name + ":ERROR:" + error.getClass().getSimpleName();
    }
    public static void main(String[] args) {
        // Explicit completions make the observation order independent of a scheduler.
        CompletableFuture<String> price = new CompletableFuture<>();
        CompletableFuture<String> stock = new CompletableFuture<>();
        CompletableFuture<Void> all = CompletableFuture.allOf(price, stock);
        IllegalStateException priceError = new IllegalStateException("price unavailable");
        price.completeExceptionally(priceError);
        check(price.isCompletedExceptionally(), "price failed");
        check(!stock.isDone(), "stock still pending");
        check(!all.isDone(), "allOf waits for all inputs");
        System.out.println("after-price-failure: price.failed=" + price.isCompletedExceptionally()
                + "; stock.done=" + stock.isDone() + "; all.done=" + all.isDone());
        stock.complete("in-stock");
        check(all.isCompletedExceptionally(), "allOf now completed exceptionally");
        check(failureOf(all) == priceError, "single input failure is preserved as cause");
        check(stock.join().equals("in-stock"), "successful sibling keeps its result");
        System.out.println("after-stock-success: all.failed=" + all.isCompletedExceptionally()
                + "; cause=" + failureOf(all).getClass().getSimpleName()
                + "; stock=" + stock.join());

        CompletableFuture<String> first = new CompletableFuture<>();
        CompletableFuture<String> later = new CompletableFuture<>();
        CompletableFuture<Object> any = CompletableFuture.anyOf(first, later);
        first.completeExceptionally(new IllegalArgumentException("first failed"));
        check(any.isCompletedExceptionally(), "anyOf accepts exceptional completion");
        check(!later.isDone(), "anyOf does not finish its sibling");
        later.complete("later success");
        check(failureOf(any) instanceof IllegalArgumentException, "later success does not replace failure");
        System.out.println("anyOf: first=ERROR; later=OK; aggregate="
                + failureOf(any).getClass().getSimpleName());

        CompletableFuture<String> childA = new CompletableFuture<>();
        CompletableFuture<String> childB = new CompletableFuture<>();
        CompletableFuture<Void> cancelled = CompletableFuture.allOf(childA, childB);
        check(cancelled.cancel(true), "aggregate cancellation succeeds");
        check(!childA.isDone() && !childB.isDone(), "cancellation is not propagated to inputs");
        System.out.println("cancel-aggregate: cancelled=" + cancelled.isCancelled()
                + "; childA.done=" + childA.isDone() + "; childB.done=" + childB.isDone());
        childA.complete("A");
        childB.complete("B");
        check(cancelled.isCancelled(), "aggregate remains cancelled");
        check(childA.join().equals("A") && childB.join().equals("B"), "children can still complete");

        CompletableFuture<String> a = new CompletableFuture<>();
        CompletableFuture<String> b = new CompletableFuture<>();
        CompletableFuture<String> c = new CompletableFuture<>();
        List<CompletableFuture<String>> outcomes = List.of(
                a.handle((value, error) -> outcome("A", value, error)),
                b.handle((value, error) -> outcome("B", value, error)),
                c.handle((value, error) -> outcome("C", value, error)));
        CompletableFuture<Void> collected = CompletableFuture.allOf(
                outcomes.toArray(CompletableFuture[]::new));
        b.completeExceptionally(new IllegalArgumentException("B failed"));
        c.complete("ready");
        check(!collected.isDone(), "collect waits for uncompleted A");
        a.completeExceptionally(new IllegalStateException("A failed"));
        check(collected.join() == null, "allOf has no result list");
        List<String> report = outcomes.stream().map(CompletableFuture::join).toList();
        check(report.equals(List.of("A:ERROR:IllegalStateException", "B:ERROR:IllegalArgumentException",
                "C:OK:ready")), "report keeps every outcome in input order");
        System.out.println("collected=" + report);
        check(CompletableFuture.allOf().join() == null, "empty allOf is complete");
        check(!CompletableFuture.anyOf().isDone(), "empty anyOf is incomplete");
        System.out.println("empty: allOf.done=" + CompletableFuture.allOf().isDone()
                + "; anyOf.done=" + CompletableFuture.anyOf().isDone());
        System.out.println("PASS " + checks);
    }
}