Question

在回答this question时，我注意到CompletableFuture的一种奇怪行为：如果您有CompletableFuture cf并与cf.exceptionally()建立联系，则会出现呼叫cf.get()表现得很奇怪：

如果您在特殊完成之前调用它，它会在返回之前等待exceptionally()块的执行
否则，通过抛出预期的ExecutionException

我错过了什么或这是一个错误吗？我在Ubuntu 17.04上使用Oracle JDK 1.8.0_131。

以下代码说明了这种现象：

public static void main(String[] args) {
    long start = System.currentTimeMillis();
    final CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
        sleep(1000);
        throw new RuntimeException("First");
    }).thenApply(Function.identity());

    future.exceptionally(e -> {
        sleep(1000);
        logDuration(start, "Exceptionally");
        return null;
    });

    final CompletableFuture<Void> futureA = CompletableFuture.runAsync(() -> {
        try {
            future.get();
        } catch (Exception e) {
        } finally {
            logDuration(start, "A");
        }
    });

    final CompletableFuture<Void> futureB = CompletableFuture.runAsync(() -> {
        sleep(1100);
        try {
            future.get();
        } catch (Exception e) {
        } finally {
            logDuration(start, "B");
        }
    });

    try {
        future.join();
    } catch (Exception e) {
        logDuration(start, "Main");
    }

    futureA.join();
    futureB.join();
}

private static void sleep(final int millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

private static void logDuration(long start, String who) {
    System.out.println(who + " waited for " + (System.currentTimeMillis() - start) + "ms");
}

输出：

B waited for 1347ms
Exceptionally waited for 2230ms
Main waited for 2230ms
A waited for 2230ms

正如您所看到的，futureB在调用get()之前稍微睡了一下并不会阻塞。但是，futureA和主线程都等待exceptionally()完成。

请注意，如果删除.thenApply(Function.identity())。

，则不会发生此行为

Answer 1

唤醒睡眠线程是一项依赖操作，必须像其他操作一样处理，并且没有优先权。另一方面，轮询CompletableFuture时已经完成的线程将不会被唤醒，不需要被唤醒，因此，无需与其他相关动作竞争。

使用以下程序

public static void main(String[] args) {
    final CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
        waitAndLog("Supplier", null, 1000);
        throw new RuntimeException("First");
    }).thenApply(Function.identity());
    long start = System.nanoTime();

    CompletableFuture.runAsync(() -> waitAndLog("A", future, 0));

    LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(10));

    future.exceptionally(e -> {
        waitAndLog("Exceptionally", null, 1000);
        return null;
    });

    CompletableFuture.runAsync(() -> waitAndLog("B", future, 0));
    CompletableFuture.runAsync(() -> waitAndLog("C", future, 1100));

    waitAndLog("Main", future, 0);
    ForkJoinPool.commonPool().awaitQuiescence(10, TimeUnit.SECONDS);
}
private static void waitAndLog(String msg, CompletableFuture<?> primary, int sleep) {
    long nanoTime = System.nanoTime();
    Object result;
    try {
        if(sleep>0) Thread.sleep(sleep);
        result = primary!=null? primary.get(): null;
    } catch (InterruptedException|ExecutionException ex) {
        result = ex;
    }
    long millis=TimeUnit.NANOSECONDS.toMillis(System.nanoTime()-nanoTime);
    System.out.println(msg+" waited for "+millis+"ms"+(result!=null? ", got "+result: ""));
}

我明白了，

Supplier waited for 993ms
A waited for 993ms, got java.util.concurrent.ExecutionException: java.lang.RuntimeException: First
C waited for 1108ms, got java.util.concurrent.ExecutionException: java.lang.RuntimeException: First
Exceptionally waited for 998ms
Main waited for 1983ms, got java.util.concurrent.ExecutionException: java.lang.RuntimeException: First
B waited for 1984ms, got java.util.concurrent.ExecutionException: java.lang.RuntimeException: First

在我的计算机上，建议在此特定情况下，依赖操作按照计划的顺序执行，A首先执行。请注意，我在安排Exceptionally之前插入了额外的等待时间，这将是下一个相关操作。由于B在后台线程中运行，因此它是否设法在Main线程之前安排自己是不确定的。我们可以在执行订单之前插入另一个延迟。

由于C轮询已经完成的未来，它可以立即进行，因此其净等待时间接近明确指定的休眠时间。

必须强调的是，这只是特定情况的结果，取决于实施细节。依赖操作没有保证的执行顺序。正如您可能已经注意到的那样，没有.thenApply(Function.identity())步骤，实现会运行不同的代码路径，从而导致相关操作的执行顺序不同。

依赖关系形成一个树，实现必须以有效的方式遍历它，而不会有堆栈溢出的风险，因此它必须以某种方式将其展平，并且依赖关系树的形状的微小变化可能会影响生成的顺序。一种非直观的方式。

为什么在异常完成之前调用get（）会等待异常执行？

1 个答案: