【JUC —— 11 CompletableFuture 异步回调 】

在 Java 中，Future 接口表示一个异步计算的结果，但它并没有直接提供异步回调的能力。通常情况下，我们使用 Future 来表示一个异步任务，并通过阻塞方法 get() 来获取结果。为了实现异步回调功能，我们可以结合 Future 和其他工具类，比如 ExecutorService 和 CompletableFuture。

使用 CompletableFuture 实现异步回调

CompletableFuture 是 Java 8 引入的一个强大的工具类，继承自 Future 接口，并提供了丰富的异步编程能力，包括回调方法。

基本用法

1. 创建并执行异步任务

supplyAsync 方法用于异步执行任务，

thenAccept 方法注册了一个回调，当异步任务完成时，会自动调用这个回调并传递结果。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 创建并执行异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, World!";
        });

        // 注册回调
        future.thenAccept(result -> System.out.println("异步任务完成，结果: " + result));
        future
                .whenCompleteAsync((integer, throwable) -> System.out.println(Thread.currentThread().getName()+": " + integer + throwable+" "))
                .whenComplete((integer, throwable) -> System.out.println(Thread.currentThread().getName()+": " + integer + throwable+" "));
        completableFuture.thenAccept(x -> System.out.println(Thread.currentThread().getName()+": " + x));
        System.out.println(Thread.currentThread().getName()+": main");  

        // 主线程继续执行其他任务
        System.out.println("主线程继续执行其他任务");

        // 阻塞主线程，等待异步任务完成
        try {

            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/*
main: main
ForkJoinPool.commonPool-worker-1: 123
*/

2. 链式调用

CompletableFuture 支持链式调用，可以注册多个回调或组合多个异步任务。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureChainExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        }).thenApply(result -> result + ", World!")
          .thenApply(result -> result + " from CompletableFuture")
          .thenAccept(result -> System.out.println("最终结果: " + result));      

        System.out.println("主线程继续执行其他任务");

        // 阻塞主线程，等待异步任务完成
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

使用 ExecutorService 和 Future

虽然 Future 本身不支持回调，但可以结合 ExecutorService 以及自定义逻辑实现类似回调的功能。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureCallbackExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 提交异步任务
        Future<String> future = executor.submit(() -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, World!";
        });

        // 启动一个线程，监控任务的完成情况
        new Thread(() -> {
            try {
                // 阻塞等待结果
                String result = future.get();
                // 异步任务完成后的回调逻辑
                System.out.println("异步任务完成，结果: " + result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        System.out.println("主线程继续执行其他任务");

        // 关闭线程池
        executor.shutdown();
    }
}

• CompletableFuture 提供了更为丰富和便捷的异步编程能力，包括异步回调、链式调用、组合多个异步任务等功能。
• 在 Java 8 及以上版本中，推荐使用 CompletableFuture 实现异步回调功能。
• 而对于 Java 7 及以下版本，可以结合 ExecutorService 和 Future 自定义异步回调逻辑。