Java中FutureTask 和 CompletableFuture的区别

本文主要介绍了Java中FutureTask 和 CompletableFuture的区别吗,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

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

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

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

一、核心区别对比表

特性	FutureTask	CompletableFuture
设计理念	一个任务的包装器	一个异步计算的流水线/阶段（Stage）
继承体系	实现 Runnable 和 Future	实现 Future 和 CompletionStage
结果获取	阻塞式 (get())	阻塞式 (get()) + 非阻塞回调 (thenXXX)
组合能力	无。需手动编排多个Future	极其强大。thenCompose, thenCombine, allOf, anyOf
异常处理	get() 时抛出 ExecutionException	流式处理 (exceptionally, handle)
手动完成	困难，需通过子类覆盖等技巧	内置 (complete, completeExceptionally)
状态转换	内部复杂状态机（NEW, COMPLETING, NORMAL…）	更高级的抽象，对开发者更透明
依赖关系	无内置支持	有，后续阶段自动依赖前序阶段的完成
适用场景	简单的、一次性的异步任务执行	复杂的、需要链式调用和组合的全链路异步化
类比	手动扳手 - 功能单一可靠	智能电动工具套装 - 功能强大自动化

二、深入解析关键区别

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.submit()	足够简单，无需引入复杂的链式API。
需要手动控制任务执行（如放入特定线程）	FutureTask	它本身是 Runnable，可以直接交给 Thread 执行。
复杂的异步流水线（任务依赖、结果聚合、超时控制）	CompletableFuture	其强大的组合和异常处理能力是唯一选择。
高并发、高吞吐量服务	CompletableFuture	非阻塞回调能最大限度利用线程资源，避免阻塞等待。
响应式编程/全链路异步	CompletableFuture	它是构建非阻塞应用的基础，是现代Java异步编程的事实标准。

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

到此这篇关于Java中FutureTask 和 CompletableFuture的区别的文章就介绍到这了,更多相关Java FutureTask 和 CompletableFuture内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

• 详解Java CompletableFuture使用方法以及与FutureTask的区别