Java CompletableFuture：异步编程

好的，各位尊敬的程序员同仁们，欢迎来到今天的“Java CompletableFuture：异步编程，让你的代码飞起来🚀”讲座！我是你们的老朋友，今天就让我们一起揭开CompletableFuture这件异步编程的神秘面纱，让你的代码不再慢吞吞，而是像猎豹一样迅猛！

开场白：告别堵车的日子

想象一下，你每天早上都得开车上班，结果呢？堵！堵！堵！红灯、车辆、喇叭声，简直是噩梦。同步编程就像这样，所有任务都要排队执行，一个任务没完成，后面的就得等着。这效率，简直让人抓狂！

但是，有了CompletableFuture，你就相当于拥有了一辆私人飞机✈️，可以绕过拥堵的路段，直接飞到目的地。异步编程，就是让你的程序可以同时处理多个任务，不用傻傻地等待，效率自然就提高了。

第一幕：什么是CompletableFuture？（概念篇）

CompletableFuture，顾名思义，它是一个代表未来计算结果的Future，并且可以异步地完成。你可以把它想象成一张“兑奖券”，代表着某个异步操作的结果。你不用一直盯着这张券，等着它开奖，你可以先去干别的事情，等开奖的时候，它会通知你。

更学术一点地说，CompletableFuture实现了Future和CompletionStage接口。Future接口提供了基本的get()方法来获取结果，但它是阻塞的。而CompletionStage接口则提供了一系列方法来组合、转换和处理异步操作的结果，让异步编程变得更加灵活和强大。

第二幕：同步 vs. 异步（对比篇）

为了更直观地理解CompletableFuture的威力，我们先来回顾一下同步和异步的区别。

特性	同步编程	异步编程
执行方式	线性执行，一个任务完成后才能执行下一个	并发执行，多个任务可以同时进行
阻塞性	阻塞，调用方必须等待结果返回	非阻塞，调用方可以继续执行其他任务
资源利用率	较低，CPU可能在等待IO时空闲	较高，CPU可以同时处理多个任务，提高利用率
适用场景	IO密集型任务，对响应时间要求不高	IO密集型任务，对响应时间要求高，需要并发处理
调试难度	相对简单	相对复杂，需要考虑线程安全和异常处理
代码复杂度	较低	较高，需要使用回调函数或CompletableFuture等工具

举个例子，你去餐厅吃饭，同步就像你坐在座位上，等着服务员把所有菜都上齐了，你才能开始吃。而异步就像你点了菜之后，可以先去玩手机📱，等菜做好了，服务员会通知你来吃。

第三幕：CompletableFuture的常用方法（实战篇）

CompletableFuture提供了丰富的方法，让我们像玩乐高积木一样，灵活地组合和处理异步操作。

1. 创建CompletableFuture

   • CompletableFuture.runAsync(Runnable runnable): 执行一个没有返回值的异步任务。

     CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
         System.out.println("执行一个异步任务");
     });

   • CompletableFuture.supplyAsync(Supplier<T> supplier): 执行一个有返回值的异步任务。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
         return "异步任务的结果";
     });

   • CompletableFuture.completedFuture(T value): 创建一个已经完成的CompletableFuture，直接返回指定的值。

     CompletableFuture<String> future = CompletableFuture.completedFuture("已经完成的结果");

2. 获取结果

   • future.get(): 阻塞地获取结果，直到任务完成。 （慎用！ 容易造成程序卡顿）
   • future.get(long timeout, TimeUnit unit): 带超时时间的阻塞获取结果。 （相对安全）
   • future.join(): 类似get()，但不抛出检查型异常。
   • future.getNow(T valueIfAbsent): 如果任务已经完成，则返回结果；否则返回指定的默认值。
   • future.isDone(): 判断任务是否已经完成。

3. 组合CompletableFuture

   这才是CompletableFuture的精髓所在！你可以像搭积木一样，把多个CompletableFuture组合起来，形成复杂的异步流程。

   • future.thenApply(Function<T, U> fn): 当future完成后，对结果应用一个函数，返回一个新的CompletableFuture。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello");
     CompletableFuture<String> future2 = future.thenApply(s -> s + " world");
     // future2 的结果是 "hello world"

   • future.thenAccept(Consumer<T> consumer): 当future完成后，对结果执行一个Consumer，没有返回值。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello");
     future.thenAccept(s -> System.out.println("结果是：" + s));

   • future.thenRun(Runnable action): 当future完成后，执行一个Runnable，没有返回值，也不关心future的结果。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello");
     future.thenRun(() -> System.out.println("任务完成了"));

   • future.thenCompose(Function<T, CompletionStage<U>> fn): 当future完成后，对结果应用一个函数，该函数返回一个新的CompletableFuture，然后将这两个CompletableFuture合并成一个。 （重点！ 用于异步任务的串行执行）

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello");
     CompletableFuture<String> future2 = future.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " world"));
     // future2 的结果是 "hello world"

   • future.thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): 当future和other都完成后，对它们的结果应用一个BiFunction，返回一个新的CompletableFuture。 （重点！ 用于异步任务的并行执行）

     CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "hello");
     CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
     CompletableFuture<String> future3 = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
     // future3 的结果是 "hello world"

   • future.thenAcceptBoth(CompletionStage<U> other, BiConsumer<T, U> consumer): 当future和other都完成后，对它们的结果执行一个BiConsumer，没有返回值。

     CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "hello");
     CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
     future1.thenAcceptBoth(future2, (s1, s2) -> System.out.println(s1 + " " + s2));

   • future.runAfterBoth(CompletionStage<?> other, Runnable action): 当future和other都完成后，执行一个Runnable，没有返回值，也不关心它们的结果。

   • future.applyToEither(CompletionStage<T> other, Function<T, U> fn): 当future或other中任何一个完成后，对它的结果应用一个函数，返回一个新的CompletableFuture。 （重点！ 用于处理竞争条件，例如从多个数据源获取数据，哪个先返回就用哪个）

     CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
         try {
             Thread.sleep(200); // 模拟耗时操作
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         return "hello";
     });
     CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
     CompletableFuture<String> future3 = future1.applyToEither(future2, s -> s);
     // future3 的结果是 "world" (因为future2先完成)

   • future.acceptEither(CompletionStage<T> other, Consumer<T> consumer): 当future或other中任何一个完成后，对它的结果执行一个Consumer，没有返回值。

   • future.runAfterEither(CompletionStage<?> other, Runnable action): 当future或other中任何一个完成后，执行一个Runnable，没有返回值，也不关心它们的结果。

4. 异常处理

   异步编程中，异常处理尤为重要。CompletableFuture提供了一些方法来处理异常情况。

   • future.exceptionally(Function<Throwable, T> fn): 当future抛出异常时，对异常应用一个函数，返回一个备用值。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
         throw new RuntimeException("发生错误");
     });
     CompletableFuture<String> future2 = future.exceptionally(ex -> "备用值");
     // future2 的结果是 "备用值"

   • future.handle(BiFunction<T, Throwable, U> fn): 当future完成时（无论成功还是失败），对结果和异常应用一个BiFunction，返回一个新的CompletableFuture。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
         if (Math.random() > 0.5) {
             throw new RuntimeException("发生错误");
         }
         return "成功";
     });
     CompletableFuture<String> future2 = future.handle((result, ex) -> {
         if (ex != null) {
             System.err.println("捕获到异常：" + ex.getMessage());
             return "备用值";
         } else {
             return result;
         }
     });

   • future.whenComplete(BiConsumer<T, Throwable> action): 当future完成时（无论成功还是失败），对结果和异常执行一个BiConsumer，没有返回值。

     CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
         if (Math.random() > 0.5) {
             throw new RuntimeException("发生错误");
         }
         return "成功";
     });
     future.whenComplete((result, ex) -> {
         if (ex != null) {
             System.err.println("捕获到异常：" + ex.getMessage());
         } else {
             System.out.println("结果是：" + result);
         }
     });

第四幕：CompletableFuture的线程池（幕后功臣）

CompletableFuture默认使用ForkJoinPool.commonPool()作为默认的线程池。这是一个共享的、全局的线程池。如果你想自定义线程池，可以在创建CompletableFuture时指定。

ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 在自定义线程池中执行任务
    return "hello";
}, executor);

选择合适的线程池非常重要。如果你的任务是CPU密集型的，可以选择一个大小与CPU核心数相近的线程池。如果你的任务是IO密集型的，可以选择一个更大的线程池。

第五幕：CompletableFuture的应用场景（大显身手）

CompletableFuture在各种场景下都能大显身手，例如：

• 微服务架构: 在微服务之间进行异步调用，提高系统的吞吐量和响应速度。
• 并发爬虫: 同时抓取多个网页，提高爬虫的效率。
• GUI编程: 在后台执行耗时操作，避免阻塞UI线程，提高用户体验。
• 数据处理: 并行处理大量数据，提高数据处理的速度。
• 事件驱动编程: 异步处理事件，提高系统的响应速度和可扩展性。

第六幕：CompletableFuture的注意事项（避坑指南）

在使用CompletableFuture时，需要注意以下几点：

• 避免阻塞: 尽量避免使用future.get()方法，因为它会阻塞当前线程。可以使用future.getNow()或future.join()方法，或者使用回调函数来处理结果。
• 处理异常: 一定要处理异步任务中可能抛出的异常，否则可能会导致程序崩溃。可以使用future.exceptionally()、future.handle()或future.whenComplete()方法来处理异常。
• 选择合适的线程池: 根据任务的类型选择合适的线程池，避免资源浪费或性能瓶颈。
• 注意线程安全: 如果多个线程需要访问同一个CompletableFuture，需要注意线程安全问题。可以使用synchronized关键字或java.util.concurrent包中的并发工具类来保证线程安全。
• 避免死锁: 在使用thenCombine()等方法时，需要注意避免死锁。

第七幕：CompletableFuture vs. RxJava (竞争与合作)

CompletableFuture和RxJava都是用于异步编程的工具，它们各有优缺点。

• CompletableFuture: 是Java原生提供的，学习成本较低，适用于简单的异步流程。
• RxJava: 是一个功能强大的响应式编程库，提供了丰富的操作符，适用于复杂的异步流程。

你可以根据实际情况选择合适的工具。如果你的项目只需要简单的异步功能，CompletableFuture就足够了。如果你的项目需要处理复杂的异步事件流，RxJava可能更适合。

第八幕：总结与展望（未来可期）

CompletableFuture是Java中非常重要的异步编程工具，它可以帮助你提高程序的性能和响应速度。掌握CompletableFuture，你就可以告别堵车的日子，让你的代码像猎豹一样迅猛！🐆

随着Java的不断发展，CompletableFuture的功能也会越来越强大。我们可以期待未来CompletableFuture在异步编程领域发挥更大的作用。

尾声：练习与思考

为了巩固今天所学的内容，请大家尝试完成以下练习：

1. 使用CompletableFuture实现一个并发爬虫，抓取多个网页的内容。
2. 使用CompletableFuture实现一个异步的数据处理流程，从多个数据源获取数据，然后进行聚合和分析。
3. 比较CompletableFuture和RxJava的优缺点，并选择合适的工具来解决实际问题。

感谢大家的聆听！希望今天的讲座对你有所帮助。祝大家编程愉快，代码飞起！ 🚀😊