FutureTask 和 CompletableFuture的区别

FutureTask 和 CompletableFuture 虽然都用于异步编程，但它们在设计理念、功能性和适用场景上有着天壤之别。

可以将 FutureTask 视为一把手动扳手，功能单一但可靠；而 CompletableFuture 则是一个智能电动工具套装，功能强大且自动化程度高。

以下是它们的详细区别，我用一个表格进行概括，然后深入解释：

一、核心区别对比表

二、深入解析关键区别

1. 核心设计理念：任务 (Task) vs. 阶段 (Stage)

这是最根本的区别。

• FutureTask： 它的核心是包装一个任务（Callable 或 Runnable）。你创建一个 FutureTask 对象，把它丢给一个线程去执行，然后它代表那个单一任务的执行结果。它的关注点是“执行”这个动作本身。
• CompletableFuture： 它的核心是代表一个异步计算的阶段。它源自 CompletionStage 接口。你不需要关心这个阶段背后的任务是如何被执行的（可能是线程池，也可能是其他方式）。你更关心的是这个阶段完成后要做什么，以及它如何与其他阶段连接起来。它的关注点是“组合与流转”。

2. 结果获取方式：阻塞 vs. 非阻塞回调

• FutureTask：

  FutureTask<String> futureTask = new FutureTask<>(() -> "Result");
  new Thread(futureTask).start();
  
  // 你必须主动调用 get()，线程会在此阻塞直到结果可用
  String result = futureTask.get(); // <- 阻塞点！
  

  问题：get() 方法是阻塞的，在等待结果时线程无法做其他事情，浪费资源。

• CompletableFuture：

  CompletableFuture.supplyAsync(() -> "Result")
                   .thenAccept(result -> System.out.println("Got: " + result)); // 非阻塞回调
                   
  // 主线程可以立即继续执行，无需等待
  System.out.println("Main thread continues...");
  

  优势：通过 thenAccept, thenApply 等回调方法，注册一个动作，当结果可用时自动执行。调用线程不会被阻塞，极大地提高了系统的吞吐量。

3. 组合与链式编程：无能 vs. 强大

这是 CompletableFuture 碾压性优势的地方。

• FutureTask： 几乎没有组合能力。如果你想在任务A完成后，将其结果传给任务B，你需要手动管理：

  FutureTask<String> taskA = ...;
  FutureTask<String> taskB = new FutureTask<>(() -> {
      String aResult = taskA.get(); // 这里会阻塞任务B的执行线程！
      return process(aResult);
  });
  new Thread(taskB).start();
  

  这种方式既笨拙又会导致线程阻塞，无法高效利用资源。

• CompletableFuture： 提供了一整套函数式的流式操作符。

  • thenCompose() (扁平化映射): 用于串联两个有依赖关系的异步任务。

    CompletableFuture<String> future = getUserAsync(id)
        .thenCompose(user -> getOrderAsync(user)); // 返回 CompletableFuture<String>
    

  • thenCombine() (合并结果): 合并两个独立异步任务的结果。

    CompletableFuture<Double> future = getPriceAsync()
        .thenCombine(getTaxRateAsync(), (price, rate) -> price * rate);
    

  • allOf() / anyOf(): 等待所有任务完成或任意一个任务完成。

    CompletableFuture<Void> all = CompletableFuture.allOf(future1, future2, future3);
    all.thenRun(() -> /* 所有任务都完成了 */);
    

4. 异常处理：粗暴 vs. 优雅

• FutureTask： 任务执行中的异常会被捕获，然后在调用 get() 时包装成 ExecutionException 抛出。你只能在一个集中的地方进行 try-catch，处理逻辑不灵活。

  try {
      futureTask.get();
  } catch (ExecutionException e) {
      Throwable cause = e.getCause(); // 获取真正的异常
      // 处理异常
  }
  

• CompletableFuture： 提供了流式的异常处理机制，可以非常优雅地在流水线的任何一步进行恢复或处理。

  • exceptionally()： 类似于 catch，提供降级结果。

    CompletableFuture.supplyAsync(() -> mightFail())
                     .exceptionally(ex -> "Default Value");
    

  • handle()： 类似于 finally，无论成功失败都会执行，并可转换结果。

    .handle((result, ex) -> {
        if (ex != null) {
            return "Recovered from: " + ex.getMessage();
        }
        return result;
    });
    

三、总结与选择建议

结论：FutureTask 是一个更底层、更基础的构建块，是 ExecutorService 框架的基石。而 CompletableFuture 是一个站在 FutureTask 等基础组件之上的、更高级的、面向现代异步编程需求的API和编程模型。对于新项目，绝大多数情况下都应优先使用 CompletableFuture。