模块 java.base
包 java.util.concurrent

类 CompletableFuture<T>

java.lang.Object
java.util.concurrent.CompletableFuture<T>
类型参数：
T - 此未来的 join 和 get 方法返回的结果类型
所有已实现的接口：
CompletionStage<T> , Future<T>
public class CompletableFuture<T> extends Object implements Future <T>, CompletionStage <T>
A Future 可以显式完成（设置其值和状态），并可以用作 CompletionStage ，支持在其完成时触发的依赖函数和操作。

当两个或多个线程尝试 complete 、 completeExceptionally 或 cancel CompletableFuture 时，只有其中一个成功。

除了这些和直接操作状态和结果的相关方法之外，CompletableFuture 还使用以下策略实现接口 CompletionStage ：

  • 为 non-async 方法的依赖完成提供的操作可以由完成当前 CompletableFuture 的线程或由完成方法的任何其他调用者执行。
  • 所有没有显式 Executor 参数的 async 方法都使用 ForkJoinPool.commonPool() 执行（除非它不支持至少两个并行级别，在这种情况下，将创建一个新线程来运行每个任务）。这可以通过定义方法 defaultExecutor() 来覆盖子类中的非静态方法。为了简化监控、调试和跟踪，所有生成的异步任务都是标记接口 CompletableFuture.AsynchronousCompletionTask 的实例。具有时间延迟的操作可以使用此类中定义的适配器方法，例如：supplyAsync(supplier, delayedExecutor(timeout, timeUnit))。为了支持具有延迟和超时的方法，此类最多维护一个守护线程用于触发和取消操作，而不是用于运行它们。
  • 所有 CompletionStage 方法都是独立于其他公共方法实现的，因此一个方法的行为不会受到子类中其他方法重写的影响。
  • 所有 CompletionStage 方法都返回 CompletableFutures。要将用法限制为仅在接口 CompletionStage 中定义的那些方法，请使用方法 minimalCompletionStage() 。或者只确保客户自己不修改未来，使用方法 copy() 。

CompletableFuture 还使用以下策略实现 Future ：

  • 由于（与 FutureTask 不同）此类无法直接控制导致其完成的计算，因此取消被视为异常完成的另一种形式。方法 cancel 与 completeExceptionally(new CancellationException()) 具有相同的效果。方法 isCompletedExceptionally() 可用于确定 CompletableFuture 是否以任何异常方式完成。
  • 如果异常完成并出现 CompletionException，方法 get() 和 get(long, TimeUnit) 会抛出一个 ExecutionException ，其原因与相应的 CompletionException 中的原因相同。为了简化大多数情况下的使用，此类还定义了方法 join() 和 getNow(T) ，它们在这些情况下直接抛出 CompletionException。

用于为接受它们的方法传递完成结果的参数（即，对于类型为 T 的参数）可能为 null，但为任何其他参数传递 null 值将导致抛出 NullPointerException 。

此类的子类通常应覆盖“虚拟构造函数”方法 newIncompleteFuture() ，该方法建立 CompletionStage 方法返回的具体类型。例如，这是一个替代不同默认执行器并禁用 obtrude 方法的类：

 
 class MyCompletableFuture<T> extends CompletableFuture<T> {
  static final Executor myExecutor = ...;
  public MyCompletableFuture() { }
  public <U> CompletableFuture<U> newIncompleteFuture() {
   return new MyCompletableFuture<U>(); }
  public Executor defaultExecutor() {
   return myExecutor; }
  public void obtrudeValue(T value) {
   throw new UnsupportedOperationException(); }
  public void obtrudeException(Throwable ex) {
   throw new UnsupportedOperationException(); }
 }
自从：
1.8

  • 构造方法详细信息

    • CompletableFuture

      public CompletableFuture()
      创建一个新的不完整的 CompletableFuture。

  • 方法详情

    • supplyAsync

      public static <U> CompletableFuture <U> supplyAsync(Supplier <U> supplier)
      返回一个新的 CompletableFuture，它由 ForkJoinPool.commonPool() 中运行的任务异步完成，其值是通过调用给定的 Supplier 获得的。
      类型参数：
      U - 函数的返回类型
      参数：
      supplier - 返回用于完成返回的 CompletableFuture 的值的函数
      返回：
      新的 CompletableFuture

    • supplyAsync

      public static <U> CompletableFuture <U> supplyAsync(Supplier <U> supplier, Executor  executor)
      返回一个新的 CompletableFuture，它由在给定执行器中运行的任务异步完成，其值是通过调用给定供应商获得的。
      类型参数：
      U - 函数的返回类型
      参数：
      supplier - 返回用于完成返回的 CompletableFuture 的值的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletableFuture

    • runAsync

      public static CompletableFuture <Void > runAsync(Runnable  runnable)
      返回一个新的 CompletableFuture，它在运行给定操作后由 ForkJoinPool.commonPool() 中运行的任务异步完成。
      参数：
      runnable - 在完成返回的 CompletableFuture 之前运行的操作
      返回：
      新的 CompletableFuture

    • runAsync

      public static CompletableFuture <Void > runAsync(Runnable  runnable, Executor  executor)
      返回一个新的 CompletableFuture，它在运行给定操作后由在给定执行器中运行的任务异步完成。
      参数：
      runnable - 在完成返回的 CompletableFuture 之前运行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletableFuture

    • completedFuture

      public static <U> CompletableFuture <U> completedFuture(U value)
      返回一个已经用给定值完成的新的 CompletableFuture。
      类型参数：
      U - 值的类型
      参数：
      value - 值
      返回：
      完成的 CompletableFuture

    • isDone

      public boolean isDone()
      如果以任何方式完成，则返回 true：正常、异常或通过取消。
      指定者：
      isDone 在接口 Future<T> 中
      返回：
      true 如果完成

    • get

      public T  get() throws InterruptedException , ExecutionException
      如有必要，等待此未来完成，然后返回其结果。
      指定者：
      get 在接口 Future<T> 中
      返回：
      结果值
      抛出：
      CancellationException - 如果这个未来被取消
      ExecutionException - 如果这个未来异常完成
      InterruptedException - 如果当前线程在等待时被中断

    • get

      public T  get(long timeout, TimeUnit  unit) throws InterruptedException , ExecutionException , TimeoutException
      如有必要，最多等待此未来完成的给定时间，然后返回其结果（如果可用）。
      指定者：
      get 在接口 Future<T> 中
      参数：
      timeout - 最长时间等待
      unit - 超时参数的时间单位
      返回：
      结果值
      抛出：
      CancellationException - 如果这个未来被取消
      ExecutionException - 如果这个未来异常完成
      InterruptedException - 如果当前线程在等待时被中断
      TimeoutException - 如果等待超时

    • join

      public T  join()
      完成时返回结果值，如果异常完成则抛出（未经检查的）异常。为了更好地符合通用函数形式的使用，如果完成此 CompletableFuture 所涉及的计算抛出异常，则此方法抛出一个（未检查的）CompletionException ，并将底层异常作为其原因。
      返回：
      结果值
      抛出：
      CancellationException - 如果计算被取消
      CompletionException - 如果这个未来异常完成或完成计算抛出异常

    • getNow

      public T  getNow(T  valueIfAbsent)
      如果完成则返回结果值（或抛出任何遇到的异常），否则返回给定的 valueIfAbsent。
      参数：
      valueIfAbsent - 未完成时返回的值
      返回：
      结果值，如果完成，否则为给定的 valueIfAbsent
      抛出：
      CancellationException - 如果计算被取消
      CompletionException - 如果这个未来异常完成或完成计算抛出异常

    • complete

      public boolean complete(T  value)
      如果尚未完成，则将 get() 和相关方法返回的值设置为给定值。
      参数：
      value - 结果值
      返回：
      true 如果此调用导致此 CompletableFuture 转换为完成状态，否则 false

    • completeExceptionally

      public boolean completeExceptionally(Throwable  ex)
      如果尚未完成，则导致调用 get() 和相关方法以抛出给定的异常。
      参数：
      ex - 异常
      返回：
      true 如果此调用导致此 CompletableFuture 转换为完成状态，否则 false

    • thenApply

      public <U> CompletableFuture <U> thenApply(Function <? super T ,? extends U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段正常完成时，将使用此阶段的结果作为所提供函数的参数执行。

      此方法类似于 Optional.map 和 Stream.map 。

      有关异常完成的规则，请参阅 CompletionStage 文档。

      指定者：
      thenApply 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • thenApplyAsync

      public <U> CompletableFuture <U> thenApplyAsync(Function <? super T ,? extends U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，使用这个阶段的默认异步执行工具执行，这个阶段的结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenApplyAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • thenApplyAsync

      public <U> CompletableFuture <U> thenApplyAsync(Function <? super T ,? extends U> fn, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，使用提供的 Executor 执行，这个阶段的结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenApplyAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • thenAccept

      public CompletableFuture <Void > thenAccept(Consumer <? super T > action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段正常完成时，将使用此阶段的结果作为提供的操作的参数执行。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAccept 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenAcceptAsync

      public CompletableFuture <Void > thenAcceptAsync(Consumer <? super T > action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，使用这个阶段的默认异步执行工具执行，这个阶段的结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAcceptAsync 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenAcceptAsync

      public CompletableFuture <Void > thenAcceptAsync(Consumer <? super T > action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，使用提供的 Executor 执行，这个阶段的结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAcceptAsync 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • thenRun

      public CompletableFuture <Void > thenRun(Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，它会执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenRun 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenRunAsync

      public CompletableFuture <Void > thenRunAsync(Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段正常完成时，使用此阶段的默认异步执行工具执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenRunAsync 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenRunAsync

      public CompletableFuture <Void > thenRunAsync(Runnable  action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常完成时，使用提供的执行器执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenRunAsync 在接口 CompletionStage<T> 中
      参数：
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • thenCombine

      public <U, V> CompletableFuture <V> thenCombine(CompletionStage <? extends U> other, BiFunction <? super T ,? super U,? extends V> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段和另一个给定阶段都正常完成时，将以两个结果作为所提供函数的参数来执行。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenCombine 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      V - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • thenCombineAsync

      public <U, V> CompletableFuture <V> thenCombineAsync(CompletionStage <? extends U> other, BiFunction <? super T ,? super U,? extends V> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用这个阶段的默认异步执行工具执行，两个结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenCombineAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      V - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • thenCombineAsync

      public <U, V> CompletableFuture <V> thenCombineAsync(CompletionStage <? extends U> other, BiFunction <? super T ,? super U,? extends V> fn, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用提供的执行器执行，两个结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenCombineAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      V - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • thenAcceptBoth

      public <U> CompletableFuture <Void > thenAcceptBoth(CompletionStage <? extends U> other, BiConsumer <? super T ,? super U> action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，将执行两个结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAcceptBoth 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenAcceptBothAsync

      public <U> CompletableFuture <Void > thenAcceptBothAsync(CompletionStage <? extends U> other, BiConsumer <? super T ,? super U> action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用这个阶段的默认异步执行工具执行，两个结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAcceptBothAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • thenAcceptBothAsync

      public <U> CompletableFuture <Void > thenAcceptBothAsync(CompletionStage <? extends U> other, BiConsumer <? super T ,? super U> action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用提供的执行器执行，两个结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      thenAcceptBothAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 其他 CompletionStage 结果的类型
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • runAfterBoth

      public CompletableFuture <Void > runAfterBoth(CompletionStage <?> other, Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段和另一个给定阶段都正常完成时，执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterBoth 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • runAfterBothAsync

      public CompletableFuture <Void > runAfterBothAsync(CompletionStage <?> other, Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个和另一个给定阶段都正常完成时，使用这个阶段的默认异步执行工具执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterBothAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • runAfterBothAsync

      public CompletableFuture <Void > runAfterBothAsync(CompletionStage <?> other, Runnable  action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段和另一个给定阶段都正常完成时，使用提供的执行程序执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterBothAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • applyToEither

      public <U> CompletableFuture <U> applyToEither(CompletionStage <? extends T > other, Function <? super T ,U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，将以相应的结果作为所提供函数的参数执行。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      applyToEither 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • applyToEitherAsync

      public <U> CompletableFuture <U> applyToEitherAsync(CompletionStage <? extends T > other, Function <? super T ,U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用此阶段的默认异步执行工具执行，并将相应的结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      applyToEitherAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • applyToEitherAsync

      public <U> CompletableFuture <U> applyToEitherAsync(CompletionStage <? extends T > other, Function <? super T ,U> fn, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用提供的执行器执行，并将相应的结果作为提供函数的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      applyToEitherAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      other - 另一个 CompletionStage
      fn - 用于计算返回的 CompletionStage 值的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • acceptEither

      public CompletableFuture <Void > acceptEither(CompletionStage <? extends T > other, Consumer <? super T > action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，将以相应的结果作为提供的操作的参数执行。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      acceptEither 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • acceptEitherAsync

      public CompletableFuture <Void > acceptEitherAsync(CompletionStage <? extends T > other, Consumer <? super T > action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用此阶段的默认异步执行工具执行，并将相应的结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      acceptEitherAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • acceptEitherAsync

      public CompletableFuture <Void > acceptEitherAsync(CompletionStage <? extends T > other, Consumer <? super T > action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用提供的执行器执行，并将相应的结果作为提供的操作的参数。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      acceptEitherAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • runAfterEither

      public CompletableFuture <Void > runAfterEither(CompletionStage <?> other, Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，它会执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterEither 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • runAfterEitherAsync

      public CompletableFuture <Void > runAfterEitherAsync(CompletionStage <?> other, Runnable  action)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用这个阶段的默认异步执行工具执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterEitherAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      返回：
      新的 CompletionStage

    • runAfterEitherAsync

      public CompletableFuture <Void > runAfterEitherAsync(CompletionStage <?> other, Runnable  action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个或另一个给定阶段正常完成时，使用提供的执行程序执行给定的操作。有关异常完成的规则，请参阅 CompletionStage 文档。
      指定者：
      runAfterEitherAsync 在接口 CompletionStage<T> 中
      参数：
      other - 另一个 CompletionStage
      action - 在完成返回的 CompletionStage 之前执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • thenCompose

      public <U> CompletableFuture <U> thenCompose(Function <? super T ,? extends CompletionStage <U>> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，它的完成值与给定函数返回的 CompletionStage 相同。

      当这个阶段正常完成时，给定的函数被调用，这个阶段的结果作为参数，返回另一个 CompletionStage。当该阶段正常完成时，此方法返回的 CompletionStage 将以相同的值完成。

      为确保进度，提供的函数必须安排其结果的最终完成。

      此方法类似于 Optional.flatMap 和 Stream.flatMap 。

      有关异常完成的规则，请参阅 CompletionStage 文档。

      指定者：
      thenCompose 在接口 CompletionStage<T> 中
      类型参数：
      U - 返回的 CompletionStage 结果的类型
      参数：
      fn - 用于计算另一个 CompletionStage 的函数
      返回：
      新的 CompletionStage

    • thenComposeAsync

      public <U> CompletableFuture <U> thenComposeAsync(Function <? super T ,? extends CompletionStage <U>> fn)
      从接口 CompletionStage 复制的描述
      给定函数返回的 CompletionStage相同，使用此阶段的默认异步执行工具执行。

      当这个阶段正常完成时，给定的函数被调用，这个阶段的结果作为参数，返回另一个 CompletionStage。当该阶段正常完成时，此方法返回的 CompletionStage 将以相同的值完成。

      为确保进度，提供的函数必须安排其结果的最终完成。

      有关异常完成的规则，请参阅 CompletionStage 文档。

      指定者：
      thenComposeAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 返回的 CompletionStage 结果的类型
      参数：
      fn - 用于计算另一个 CompletionStage 的函数
      返回：
      新的 CompletionStage

    • thenComposeAsync

      public <U> CompletableFuture <U> thenComposeAsync(Function <? super T ,? extends CompletionStage <U>> fn, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，它的完成值与给定函数返回的 CompletionStage 相同，使用提供的 Executor 执行。

      当这个阶段正常完成时，给定的函数被调用，这个阶段的结果作为参数，返回另一个 CompletionStage。当该阶段正常完成时，此方法返回的 CompletionStage 将以相同的值完成。

      为确保进度，提供的函数必须安排其结果的最终完成。

      有关异常完成的规则，请参阅 CompletionStage 文档。

      指定者：
      thenComposeAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 返回的 CompletionStage 结果的类型
      参数：
      fn - 用于计算另一个 CompletionStage 的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • whenComplete

      public CompletableFuture <T > whenComplete(BiConsumer <? super T ,? super Throwable > action)
      从接口 CompletionStage 复制的描述
      返回一个与此阶段具有相同结果或异常的新 CompletionStage，它会在此阶段完成时执行给定的操作。

      当这个阶段完成时，将调用给定的操作，并将该阶段的结果（如果没有则为 null）和异常（如果没有则为 null）作为参数。当动作返回时，返回阶段完成。

      与方法 handle 不同，此方法并非设计用于转换完成结果，因此提供的操作不应引发异常。但是，如果确实如此，则适用以下规则：如果此阶段正常完成但提供的操作抛出异常，则返回的阶段异常完成并出现提供的操作的异常。或者，如果此阶段异常完成并且提供的操作抛出异常，则返回的阶段异常完成并出现此阶段的异常。

      指定者：
      whenComplete 在接口 CompletionStage<T> 中
      参数：
      action - 要执行的操作
      返回：
      新的 CompletionStage

    • whenCompleteAsync

      public CompletableFuture <T > whenCompleteAsync(BiConsumer <? super T ,? super Throwable > action)
      从接口 CompletionStage 复制的描述
      返回一个与此阶段具有相同结果或异常的新 CompletionStage，当此阶段完成时，它使用此阶段的默认异步执行工具执行给定的操作。

      当这个阶段完成时，将调用给定的操作，并将该阶段的结果（如果没有则为 null）和异常（如果没有则为 null）作为参数。当动作返回时，返回阶段完成。

      与方法 handleAsync 不同，此方法并非设计用于转换完成结果，因此提供的操作不应引发异常。但是，如果确实如此，则适用以下规则：如果此阶段正常完成但提供的操作抛出异常，则返回的阶段异常完成并出现提供的操作的异常。或者，如果此阶段异常完成并且提供的操作抛出异常，则返回的阶段异常完成并出现此阶段的异常。

      指定者：
      whenCompleteAsync 在接口 CompletionStage<T> 中
      参数：
      action - 要执行的操作
      返回：
      新的 CompletionStage

    • whenCompleteAsync

      public CompletableFuture <T > whenCompleteAsync(BiConsumer <? super T ,? super Throwable > action, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个与此阶段具有相同结果或异常的新 CompletionStage，当此阶段完成时，它使用提供的 Executor 执行给定的操作。

      当这个阶段完成时，将调用给定的操作，并将该阶段的结果（如果没有则为 null）和异常（如果没有则为 null）作为参数。当动作返回时，返回阶段完成。

      与方法 handleAsync 不同，此方法并非设计用于转换完成结果，因此提供的操作不应引发异常。但是，如果确实如此，则适用以下规则：如果此阶段正常完成但提供的操作抛出异常，则返回的阶段异常完成并出现提供的操作的异常。或者，如果此阶段异常完成并且提供的操作抛出异常，则返回的阶段异常完成并出现此阶段的异常。

      指定者：
      whenCompleteAsync 在接口 CompletionStage<T> 中
      参数：
      action - 要执行的操作
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • handle

      public <U> CompletableFuture <U> handle(BiFunction <? super T ,Throwable ,? extends U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数执行。

      当这个阶段完成时，将调用给定的函数，并将该阶段的结果（或null，如果没有）和异常（或null，如果没有）作为参数，函数的结果用于完成返回的阶段。

      指定者：
      handle 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • handleAsync

      public <U> CompletableFuture <U> handleAsync(BiFunction <? super T ,Throwable ,? extends U> fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当这个阶段正常或异常完成时，使用这个阶段的默认异步执行工具执行，这个阶段的结果和异常作为提供函数的参数。

      当这个阶段完成时，将调用给定的函数，并将该阶段的结果（或null，如果没有）和异常（或null，如果没有）作为参数，函数的结果用于完成返回的阶段。

      指定者：
      handleAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • handleAsync

      public <U> CompletableFuture <U> handleAsync(BiFunction <? super T ,Throwable ,? extends U> fn, Executor  executor)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段正常或异常完成时，使用提供的执行程序执行该阶段的结果和异常作为提供函数的参数。

      当这个阶段完成时，将调用给定的函数，并将该阶段的结果（或null，如果没有）和异常（或null，如果没有）作为参数，函数的结果用于完成返回的阶段。

      指定者：
      handleAsync 在接口 CompletionStage<T> 中
      类型参数：
      U - 函数的返回类型
      参数：
      fn - 用于计算返回的 CompletionStage 值的函数
      executor - 用于异步执行的执行程序
      返回：
      新的 CompletionStage

    • toCompletableFuture

      public CompletableFuture <T > toCompletableFuture()
      返回此 CompletableFuture。
      指定者：
      toCompletableFuture 在接口 CompletionStage<T> 中
      返回：
      这个 CompletableFuture

    • exceptionally

      public CompletableFuture <T > exceptionally(Function <Throwable ,? extends T > fn)
      从接口 CompletionStage 复制的描述
      返回一个新的 CompletionStage，当此阶段异常完成时，将执行此阶段的异常作为提供函数的参数。否则，如果此阶段正常完成，则返回的阶段也正常完成并具有相同的值。
      指定者：
      exceptionally 在接口 CompletionStage<T> 中
      参数：
      fn - 如果此 CompletionStage 异常完成，则用于计算返回的 CompletionStage 值的函数
      返回：
      新的 CompletionStage

    • allOf

      public static CompletableFuture <Void > allOf(CompletableFuture <?>... cfs)
      返回一个新的 CompletableFuture，它在所有给定的 CompletableFutures 完成时完成。如果任何给定的 CompletableFutures 异常完成，则返回的 CompletableFuture 也会异常完成，并且 CompletionException 将此异常作为其原因。否则，给定 CompletableFuture 的结果（如果有）不会反映在返回的 CompletableFuture 中，但可以通过单独检查它们来获得。如果未提供 CompletableFutures，则返回一个 CompletableFuture 完成值 null 。

      此方法的应用之一是在继续执行程序之前等待一组独立的 CompletableFutures 完成，如：CompletableFuture.allOf(c1, c2, c3).join();。

      参数：
      cfs - CompletableFutures
      返回：
      当所有给定的 CompletableFutures 完成时完成的新 CompletableFuture
      抛出：
      NullPointerException - 如果数组或其任何元素是 null

    • anyOf

      public static CompletableFuture <Object > anyOf(CompletableFuture <?>... cfs)
      返回一个新的 CompletableFuture，它在任何给定的 CompletableFutures 完成时完成，结果相同。否则，如果它异常完成，则返回的 CompletableFuture 也会这样做，并且 CompletionException 将此异常作为其原因。如果未提供 CompletableFuture，则返回不完整的CompletableFuture。
      参数：
      cfs - CompletableFutures
      返回：
      一个新的 CompletableFuture，它在完成时以任何给定 CompletableFutures 的结果或异常完成
      抛出：
      NullPointerException - 如果数组或其任何元素是 null

    • cancel

      public boolean cancel(boolean mayInterruptIfRunning)
      如果尚未完成，则使用 CancellationException 完成此 CompletableFuture。尚未完成的相关 CompletableFutures 也将异常完成，并由此 CancellationException 导致 CompletionException 。
      指定者：
      cancel 在接口 Future<T> 中
      参数：
      mayInterruptIfRunning - 此值在此实现中无效，因为中断未用于控制处理。
      返回：
      true 如果现在取消此任务

    • isCancelled

      public boolean isCancelled()
      如果此 CompletableFuture 在正常完成之前被取消，则返回 true。
      指定者：
      isCancelled 在接口 Future<T> 中
      返回：
      true 如果此 CompletableFuture 在正常完成之前被取消

    • isCompletedExceptionally

      public boolean isCompletedExceptionally()
      如果此 CompletableFuture 以任何方式异常完成，则返回 true。可能的原因包括取消、 completeExceptionally 的显式调用以及 CompletionStage 操作的突然终止。
      返回：
      true 如果这个 CompletableFuture 异常完成

    • obtrudeValue

      public void obtrudeValue(T  value)
      强制设置或重置方法 get() 和相关方法随后返回的值，无论是否已完成。此方法仅设计用于错误恢复操作，即使在这种情况下也可能导致使用已建立结果与覆盖结果的持续依赖完成。
      参数：
      value - 完成值

    • obtrudeException

      public void obtrudeException(Throwable  ex)
      强制导致后续调用方法 get() 和相关方法抛出给定的异常，无论是否已经完成。此方法仅设计用于错误恢复操作，即使在这种情况下也可能导致使用已建立结果与覆盖结果的持续依赖完成。
      参数：
      ex - 异常
      抛出：
      NullPointerException - 如果异常为空

    • getNumberOfDependents

      public int getNumberOfDependents()
      返回其完成正在等待此 CompletableFuture 完成的 CompletableFuture 的估计数量。此方法设计用于监视系统状态，而不用于同步控制。
      返回：
      依赖的 CompletableFutures 的数量

    • toString

      public String  toString()
      返回标识此 CompletableFuture 及其完成状态的字符串。括号中的状态包含字符串 "Completed Normally" 或字符串 "Completed Exceptionally" 或字符串 "Not completed" 后跟取决于其完成的 CompletableFutures 的数量（如果有）。
      重写：
      toString 在类 Object 中
      返回：
      标识此 CompletableFuture 及其状态的字符串

    • newIncompleteFuture

      public <U> CompletableFuture <U> newIncompleteFuture()
      返回一个新的不完整的 CompletableFuture，其类型由 CompletionStage 方法返回。子类通常应该重写此方法以返回与此 CompletableFuture 相同的类的实例。默认实现返回类 CompletableFuture 的实例。
      类型参数：
      U - 值的类型
      返回：
      一个新的 CompletableFuture
      自从：
      9

    • defaultExecutor

      public Executor  defaultExecutor()
      返回用于未指定执行器的异步方法的默认执行器。如果此类支持多个并行线程，则该类使用 ForkJoinPool.commonPool() ，否则每个异步任务使用一个线程的执行器。该方法可以在子类中被重写以返回一个至少提供一个独立线程的执行器。
      返回：
      执行人
      自从：
      9

    • copy

      public CompletableFuture <T > copy()
      返回一个正常完成的新 CompletableFuture，其正常完成时具有与此 CompletableFuture 相同的值。如果此 CompletableFuture 异常完成，则返回的 CompletableFuture 异常完成，并带有 CompletionException，此异常作为原因。该行为等同于 thenApply(x -> x) 。此方法可用作“防御性复制”的一种形式，以防止客户端完成，同时仍然能够安排相关操作。
      返回：
      新的 CompletableFuture
      自从：
      9

    • minimalCompletionStage

      public CompletionStage <T > minimalCompletionStage()
      返回一个正常完成的新 CompletionStage，其正常完成时具有与此 CompletableFuture 相同的值，并且不能独立完成或以接口 CompletionStage 的方法未定义的方式使用。如果此 CompletableFuture 异常完成，则返回的 CompletionStage 异常完成，并带有 CompletionException，此异常作为原因。

      除非被子类覆盖，否则可以通过 toCompletableFuture() 从最小的 CompletionStage 获得一个具有所有可用方法的新的非最小 CompletableFuture。例如，可以等待最小阶段的完成

       minimalStage.toCompletableFuture().join();
      返回：
      新的 CompletionStage
      自从：
      9

    • completeAsync

      public CompletableFuture <T > completeAsync(Supplier <? extends T > supplier, Executor  executor)
      使用给定的执行程序从异步任务调用的给定供应商函数的结果完成此 CompletableFuture。
      参数：
      supplier - 返回用于完成此 CompletableFuture 的值的函数
      executor - 用于异步执行的执行程序
      返回：
      这个 CompletableFuture
      自从：
      9

    • completeAsync

      public CompletableFuture <T > completeAsync(Supplier <? extends T > supplier)
      使用默认执行程序从异步任务调用的给定 Supplier 函数的结果完成此 CompletableFuture。
      参数：
      supplier - 返回用于完成此 CompletableFuture 的值的函数
      返回：
      这个 CompletableFuture
      自从：
      9

    • orTimeout

      public CompletableFuture <T > orTimeout(long timeout, TimeUnit  unit)
      如果在给定的超时之前没有以其他方式完成，则使用 TimeoutException 异常地完成此 CompletableFuture。
      参数：
      timeout - 以 unit 为单位异常完成 TimeoutException 之前等待多长时间
      unit - 一个 TimeUnit 决定如何解释 timeout 参数
      返回：
      这个 CompletableFuture
      自从：
      9

    • completeOnTimeout

      public CompletableFuture <T > completeOnTimeout(T  value, long timeout, TimeUnit  unit)
      如果在给定超时之前未以其他方式完成，则使用给定值完成此 CompletableFuture。
      参数：
      value - 超时时使用的值
      timeout - 使用给定值正常完成之前等待的时间，以 unit 为单位
      unit - 一个 TimeUnit 决定如何解释 timeout 参数
      返回：
      这个 CompletableFuture
      自从：
      9

    • delayedExecutor

      public static Executor  delayedExecutor(long delay, TimeUnit  unit, Executor  executor)
      返回一个新的 Executor，它在给定的延迟后（如果为非正则则不延迟）向给定的基本执行器提交任务。每个延迟都在调用返回的执行程序的 execute 方法时开始。
      参数：
      delay - 延迟多长时间，以 unit 为单位
      unit - 一个 TimeUnit 确定如何解释 delay 参数
      executor - 基础执行者
      返回：
      新的延迟执行人
      自从：
      9

    • delayedExecutor

      public static Executor  delayedExecutor(long delay, TimeUnit  unit)
      返回一个新的 Executor，它在给定的延迟（如果为非正数则没有延迟）后将任务提交给默认执行器。每个延迟都在调用返回的执行程序的 execute 方法时开始。
      参数：
      delay - 延迟多长时间，以 unit 为单位
      unit - 一个 TimeUnit 确定如何解释 delay 参数
      返回：
      新的延迟执行人
      自从：
      9

    • completedStage

      public static <U> CompletionStage <U> completedStage(U value)
      返回一个新的 CompletionStage，它已经用给定的值完成并且只支持接口 CompletionStage 中的那些方法。
      类型参数：
      U - 值的类型
      参数：
      value - 值
      返回：
      完成的 CompletionStage
      自从：
      9

    • failedFuture

      public static <U> CompletableFuture <U> failedFuture(Throwable  ex)
      返回一个新的 CompletableFuture，它已经异常完成并出现给定的异常。
      类型参数：
      U - 值的类型
      参数：
      ex - 异常
      返回：
      异常完成的 CompletableFuture
      自从：
      9

    • failedStage

      public static <U> CompletionStage <U> failedStage(Throwable  ex)
      返回一个新的 CompletionStage，它已经异常完成并出现给定的异常，并且仅支持接口 CompletionStage 中的那些方法。
      类型参数：
      U - 值的类型
      参数：
      ex - 异常
      返回：
      异常完成的 CompletionStage
      自从：
      9