CompletableFuture-异步操作

CompletableFuture 类简介

CompletableFuture 主要用于表示一个可能尚未完成的计算结果。它提供了大量的方法用于处理异步计算的结果，允许你在计算完成时进行后续处理，组合多个异步计算，以及处理异常情况。

常用方法

1. supplyAsync(Supplier<U> supplier)

   • 描述：异步执行一个提供者（Supplier）提供的计算任务，并返回一个 CompletableFuture 实例。
   • 适用于你希望计算某个值，并在计算完成后获取这个值的场景。它可以返回计算结果。
   • 示例：

     CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
         return 1 + 2;
     });
     

2. runAsync(Runnable runnable)

   • 描述：异步执行一个任务（Runnable），并返回一个 CompletableFuture 实例。
   • 适用于你只需要执行某个任务而不需要获取结果的场景。它只表示任务的执行状态，没有返回值。
   • 示例：

     CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
         System.out.println("Running asynchronously");
     });
     

3. thenApply(Function<? super T, ? extends U> fn)

   • 描述：在当前计算完成后，异步地将结果应用于给定的函数，并返回一个新的 CompletableFuture。
   • 示例：

     CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1)
         .thenApply(result -> result + 1);
     

4. thenAccept(Consumer<? super T> action)

   • 描述：在计算完成后异步执行一个操作（Consumer），这个操作不会返回结果。
   • 示例：

     CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1);
     future.thenAccept(result -> System.out.println("Result: " + result));
     

5. thenRun(Runnable action)

   • 描述：在当前计算完成后异步执行一个任务（Runnable），这个任务不会使用当前计算的结果。
   • 示例：

     CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> 1);
     future.thenRun(() -> System.out.println("Task completed"));
     

6. exceptionally(Function<Throwable, ? extends T> fn)

   • 描述：处理计算中发生的异常，提供一个异常处理函数（Function），如果计算出现异常，将调用该函数。
   • 示例：

     CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
         throw new RuntimeException("Error");
     }).exceptionally(ex -> {
         System.out.println("Exception: " + ex.getMessage());
         return 0;
     });
     

7. whenComplete(BiConsumer<? super T, ? super Throwable> action)

   • 描述：在计算完成后，无论成功还是失败，都执行一个操作（BiConsumer），这个操作可以访问结果和异常。
   • 示例：

     CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1);
     future.whenComplete((result, ex) -> {
         if (ex != null) {
             System.out.println("Exception: " + ex.getMessage());
         } else {
             System.out.println("Result: " + result);
         }
     });
     

8. allOf(CompletableFuture<?>... cfs)

   • 描述：当所有给定的 CompletableFuture 完成时返回一个新的 CompletableFuture，表示所有计算都完成。
   • 示例：

     CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(() -> 1);
     CompletableFuture<Void> future2 = CompletableFuture.supplyAsync(() -> 2);
     CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);
     allOfFuture.join(); // 等待所有计算完成
     

9. anyOf(CompletableFuture<?>... cfs)

   • 描述：当任意一个给定的 CompletableFuture 完成时返回一个的 CompletableFuture，表示其中一个计算完成。
   • 示例：

     CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
     CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
     CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2);
     System.out.println("First completed result: " + anyOfFuture.join());
     

10. join()

    • 描述：等待计算完成并返回计算结果。这个方法会阻塞当前线程，直到计算完成。
    • 示例：

      CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1);
      Integer result = future.join();
      System.out.println("Result: " + result);
      

示例代码

以下是一个使用 CompletableFuture 的简单示例，展示了如何异步执行任务，并处理结果和异常：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 模拟长时间运行的任务
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 5;
        }).thenApply(result -> result * 2)
          .exceptionally(ex -> {
              System.out.println("Exception: " + ex.getMessage());
              return 0;
          });

        future.thenAccept(result -> System.out.println("Result: " + result));
        future.join(); // 等待任务完成
    }
}

在这个示例中，我们创建了一个异步计算，执行一个计算并处理结果和异常，最后等待任务完成。

CompletableFuture 是一个强大的工具，可以用来简化复杂的异步操作，并使得异步编程变得更加直观。