在 java 的 completablefuture 中，whencomplete 方法用于在异步任务完成（无论是正常返回还是抛出异常）时执行一段回调逻辑。它接收一个 biconsumer 参数，该消费者函数会同时接收计算结果和可能存在的异常对象。使用该方法不会改变原 completablefuture 的最终结果或状态，它纯粹用于副作用处理，如日志记录、资源清理或监控指标上报。
whenComplete 与 handle 在处理异常时的区别是什么
whenComplete 不捕获也不转换异常，而 handle 允许通过返回值修改最终结果。当需要区分成功和失败并分别处理时，handle 更灵活；若只需观察结果而不干预流程，whenComplete 更简洁。两者都保证在任务完成后立即执行，且线程模型取决于上游任务的提交方式。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class WhenCompleteDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<string> future = CompletableFuture.supplyAsync(() -> {
System.out.println("Task running in: " + Thread.currentThread().getName());
if (Math.random() > 0.5) {
throw new RuntimeException("Simulated failure");
}
return "Success";
});
// whenComplete: 观察结果，不改变结果
CompletableFuture<string> observedFuture = future.whenComplete((result, throwable) -> {
if (throwable != null) {
System.out.println("Caught exception: " + throwable.getMessage());
} else {
System.out.println("Result is: " + result);
}
});
// 获取最终结果，如果之前抛异常，这里会抛出 ExecutionException
String finalResult = observedFuture.get();
System.out.println("Final result obtained: " + finalResult);
}
}</string></string>
上述代码展示了 whenComplete 的基本用法。无论上游任务成功还是失败，回调都会执行。如果上游抛出异常，result 为 null，throwable 包含异常实例。调用 get() 时，若存在未处理的异常，将抛出 ExecutionException。
whenComplete 的执行线程环境是怎样的
whenComplete 的回调执行线程取决于上游 CompletableFuture 的状态。如果上游任务由 ForkJoinPool.commonPool() 执行，则回调也在该池的某个线程中运行。如果上游使用了自定义线程池，则回调在该池中执行。这种设计避免了不必要的线程切换，但需注意回调中的阻塞操作可能会影响上游任务的吞吐量。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadContextDemo {
public static void main(String[] args) {
ExecutorService customExecutor = Executors.newFixedThreadPool(2, r -> {
Thread t = new Thread(r);
t.setName("Custom-Thread-" + t.getId());
return t;
});
CompletableFuture<string> future = CompletableFuture.supplyAsync(() -> {
System.out.println("Upstream task in: " + Thread.currentThread().getName());
return "Data";
}, customExecutor);
future.whenComplete((result, ex) -> {
System.out.println("WhenComplete callback in: " + Thread.currentThread().getName());
System.out.println("Result: " + result);
});
try {
Thread.sleep(2000); // Wait for completion
} catch (InterruptedException e) {
e.printStackTrace();
}
customExecutor.shutdown();
}
}</string>
运行此代码可观察到，上游任务和 whenComplete 回调通常在同一个自定义线程池中执行。这体现了 CompletableFuture 的链式调用特性：后续步骤倾向于复用上游的线程上下文，除非显式指定了新的 Executor。开发者应避免在回调中进行长时间阻塞操作，以免占用线程池资源。
whenComplete 中如果抛出异常会发生什么
如果在 whenComplete 的回调内部抛出异常，该异常会被封装进一个新的 CompletionException 中，并传递给下游的 exceptionally 或 handle 处理器。原 CompletableFuture 的状态会变为异常完成，其 get() 调用将抛出 ExecutionException。这意味着 whenComplete 中的错误处理必须谨慎，否则可能中断整个异步链路。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ExceptionPropagationDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<string> future = CompletableFuture.completedFuture("Initial");
future.whenComplete((result, ex) -> {
System.out.println("Processing: " + result);
throw new IllegalStateException("Callback error");
}).exceptionally(ex -> {
System.out.println("Exception caught downstream: " + ex.getCause().getMessage());
return "Recovered";
});
// Note: The exceptionally handler returns a value, but the original future's state is still exceptional
// To get the recovered value, we need to chain from the exceptionally returned future
// However, in this simple chain, the exceptionally handler's return value becomes the result of the exceptionally stage
// Let's demonstrate getting the result properly
CompletableFuture<string> chained = CompletableFuture.completedFuture("Initial")
.whenComplete((r, e) -> {
if (e != null) throw e;
System.out.println("In whenComplete: " + r);
throw new RuntimeException("Intentional fail");
})
.exceptionally(e -> {
System.out.println("Handling: " + e.getCause().getMessage());
return "Fallback";
});
System.out.println("Final: " + chained.get());
}
}</string></string>
此示例表明，whenComplete 中抛出的异常会被 exceptionally 捕获。开发者应确保回调逻辑健壮，或使用 handle 来更好地控制结果转换和异常处理流程。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
