CompletableFuture和Future区别？

CompletableFuture和Future都与并发编程有关，但它们有一些关键区别：

1. 异步性质：

   • Future是Java 5引入的接口，表示一个可能会在未来某个时间点返回结果的计算。它是一种同步方式来处理异步操作，你需要主动查询结果是否可用或等待结果完成。
   • CompletableFuture是Java 8引入的类，建立在Future的基础上，但更强大和灵活。它允许你更容易地构建异步操作流水线，可以将回调函数附加到操作，使得在操作完成时能够自动触发。

2. 结果设置：

   • 在Future中，结果的设置通常是由外部线程完成的，而且一旦设置就不能更改。
   • CompletableFuture允许你手动设置结果，也可以使用各种操作（如thenApply、thenCompose等）来构建异步操作链，并且可以在链中的某个步骤设置结果。

3. 异常处理：

   • Future不提供直接的异常处理机制，如果异步操作抛出异常，你需要在获取结果时手动捕获并处理。
   • CompletableFuture通过exceptionally和handle等方法提供了更方便的异常处理方式，可以轻松地捕获和处理异步操作中的异常情况。

4. 组合操作：

   • CompletableFuture提供了丰富的组合操作，如thenCombine、thenCompose、thenAcceptBoth等，可以用于将多个CompletableFuture组合在一起执行，以及构建复杂的异步操作流水线。
   • Future没有这种内置的组合操作。

总之，CompletableFuture相对于Future更加灵活和强大，特别适用于构建复杂的异步操作链，处理异常情况以及组合多个异步操作。如果你使用Java 8或更新版本，推荐使用CompletableFuture来进行异步编程。

有了Future，为什么还要CompletableFuture？

尽管Future提供了一种处理异步操作的方式，但CompletableFuture作为其增强版本在很多方面提供了更多的优势和功能，这些优势使它成为更好的选择。以下是一些原因：

1. 异步编程的便利性：CompletableFuture提供了丰富的方法，使异步编程更加便利。你可以轻松地构建异步操作链，组合多个异步任务，添加回调函数等，而不需要自己编写复杂的代码。

2. 异常处理：CompletableFuture提供了更强大的异常处理机制。你可以使用exceptionally和handle等方法捕获和处理异步操作中的异常，而不需要手动处理异常情况。

3. 组合操作：CompletableFuture支持多种组合操作，如thenCombine、thenCompose、thenAcceptBoth等，这些操作允许你以更灵活的方式组合多个异步任务，执行复杂的操作序列。

4. 非阻塞等待：CompletableFuture允许你使用join方法来非阻塞地等待异步操作的完成，而Future的get方法会阻塞当前线程，直到结果可用。

5. 异步任务的完成通知：CompletableFuture允许你注册回调函数，当异步任务完成时会自动触发这些回调，而Future需要手动查询结果。

6. 可编程性：CompletableFuture的API设计更加直观和易于理解，使得编写和维护异步代码更加容易。

总的来说，尽管Future提供了一种基本的异步编程机制，但CompletableFuture在功能和便利性上都有更多的优势，尤其在处理复杂的异步场景时，它更加强大和灵活。因此，如果你使用Java 8或更高版本，通常更倾向于使用CompletableFuture来进行异步编程。

总结

说白了，CompletableFuture比Future，有几个大的优点：

1、不阻塞 具体是回调，即回调方法自动执行。说白了，就是如果线程任务执行完成之后，回调方法会自动执行，入参是返回结果。回调的本质是异步，非阻塞。

2、并行 并行就是并发执行，说白了，本质作用和要解决的问题就是高性能，即提高性能，怎么提高？以前的多线程，都是自己执行自己的，执行完了，也不管返回结果，这个也是提高性能，但是现在不仅要提高性能，还要获取返回结果，怎么办？使用CompletableFuture，比如向2个渠道查询汇率，只要一个成功就立即返回。再比如，从多个数据库查询数据，只要一个成功就立即返回。如果是Future，那么get数据的时候是会阻塞的，虽然是多数据源并发执行，但是呢，在获取结果的时候，即get的时候，如果A线程阻塞等待，那么B线程也只能阻塞等待。这个就没有真正的并发执行同时可以并发获取结果性能高。

3、串行 即B线程依赖A线程的返回结果。说白了，就是两个线程按顺序执行。

---

刚才说的几个优点，demo代码可以参考： www.liaoxuefeng.com/wiki/125259…

第一，讲的比较清楚

第二，demo代码比较好

第三，示意图很好，一目了然。比如两个数据源，只要任意一个数据源成功就返回，而不会阻塞：

┌─────────────┐ ┌─────────────┐
│ Query Code  │ │ Query Code  │
│  from sina  │ │  from 163   │
└─────────────┘ └─────────────┘
       │               │
       └───────┬───────┘
               ▼
        ┌─────────────┐
        │    anyOf    │
        └─────────────┘
               │
       ┌───────┴────────┐
       ▼                ▼
┌─────────────┐  ┌─────────────┐
│ Query Price │  │ Query Price │
│  from sina  │  │  from 163   │
└─────────────┘  └─────────────┘
       │                │
       └────────┬───────┘
                ▼
         ┌─────────────┐
         │    anyOf    │
         └─────────────┘
                │
                ▼
         ┌─────────────┐
         │Display Price│
         └─────────────┘

官方文档-CompletableFuture

public class CompletableFuture<T>
extends Object
implements Future<T>, CompletionStage<T>

A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion. 可以显式完成（设置其值和状态）的 Future ，并且可以用作 CompletionStage ，支持在其完成时触发的依赖功能和操作。

When two or more threads attempt to complete, completeExceptionally, or cancel a CompletableFuture, only one of them succeeds. 当两个或多个线程尝试 complete 、 completeExceptionally 或 cancel CompletableFuture 时，只有其中一个成功。

In addition to these and related methods for directly manipulating status and results, CompletableFuture implements interface CompletionStage with the following policies: 除了这些以及直接操作状态和结果的相关方法之外，CompletableFuture 还实现了具有以下策略的接口 CompletionStage ：

• Actions supplied for dependent completions of non-async methods may be performed by the thread that completes the current CompletableFuture, or by any other caller of a completion method. 为非异步方法的依赖完成提供的操作可以由完成当前 CompletableFuture 的线程执行，也可以由完成方法的任何其他调用者执行。
• All async methods without an explicit Executor argument are performed using the ForkJoinPool.commonPool() (unless it does not support a parallelism level of at least two, in which case, a new Thread is created to run each task). To simplify monitoring, debugging, and tracking, all generated asynchronous tasks are instances of the marker interface CompletableFuture.AsynchronousCompletionTask. 所有没有显式 Executor 参数的异步方法都使用 ForkJoinPool.commonPool() 执行（除非它不支持至少两个并行级别，在这种情况下，将创建一个新线程来运行每个任务）。为了简化监视、调试和跟踪，所有生成的异步任务都是标记接口 CompletableFuture.AsynchronousCompletionTask 的实例。
• All CompletionStage methods are implemented independently of other public methods, so the behavior of one method is not impacted by overrides of others in subclasses. 所有 CompletionStage 方法都是独立于其他公共方法实现的，因此一种方法的行为不会受到子类中其他方法的重写的影响。

CompletableFuture also implements Future with the following policies: CompletableFuture 还通过以下策略实现 Future ：

• Since (unlike FutureTask) this class has no direct control over the computation that causes it to be completed, cancellation is treated as just another form of exceptional completion. Method cancel has the same effect as completeExceptionally(new CancellationException()). Method isCompletedExceptionally() can be used to determine if a CompletableFuture completed in any exceptional fashion. 由于（与 FutureTask 不同）此类无法直接控制导致其完成的计算，因此取消被视为异常完成的另一种形式。方法 cancel 与 completeExceptionally(new CancellationException()) 具有相同的效果。方法 isCompletedExceptionally() 可用于确定 CompletableFuture 是否以任何异常方式完成。
• In case of exceptional completion with a CompletionException, methods get() and get(long, TimeUnit) throw an ExecutionException with the same cause as held in the corresponding CompletionException. To simplify usage in most contexts, this class also defines methods join() and getNow(T) that instead throw the CompletionException directly in these cases. 如果发生 CompletionException 异常完成，方法 get() 和 get(long, TimeUnit) 会抛出 ExecutionException ，其原因与相应 CompletionException 中的原因相同。为了简化大多数上下文中的使用，此类还定义了方法 join() 和 getNow(T) ，它们在这些情况下直接抛出 CompletionException。