Java8 CompletableFuture详解：组合式异步编程-优快云博客

本文链接：https://blog.youkuaiyun.com/ldlly0505/article/details/106137463

本文介绍了Java8中的CompletableFuture，探讨了并发与并行的区别，并详细讲解了Future接口及其在异步计算中的作用。通过实例展示了如何使用CompletableFuture的sync和async方法进行异步操作，包括thenApply、thenAccept、thenRun以及它们的异步版本。还提到了thenCompose方法用于处理多层结构的future，以及thenCombine和thenAcceptBoth用于合并两个future的情况。最后讨论了allOf和anyOf的使用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

CompletableFuture：组合式异步编程

1.先了解下什么是吞吐量：

吞吐量是指对网络、设备、端口、虚电路或其他设施，单位时间内成功地传送数据的数量（以比特、字节、分组等测量）。（百科）

2.并发，并行：

并发：单个处理器核在多个任务之间切换处理

并行：多个处理器核同时处理多个任务

Future 接口

Future接口建模了一种异步计算，返回一个执行运算结果的引用，当运算结束后，这个运用hui被返回调用方。

（简单说就是你去奶茶店排队买奶茶，店员给你一个序号，你就不用在那里等待，可以去做其他事，等好了再去拿，这就是异步）

例子：

ExecutorService executor = Executors.newCachedThreadPool(); 
Future<Double> future = executor.submit(new Callable<Double>() { 
 public Double call() {
 return doSomeLongComputation(); 
 }}); 
doSomethingElse();
try { 
 Double result = future.get(2, TimeUnit.SECONDS); 
} catch (Exception e) {
 // 计算抛出一个异常
}

这种编程方式让你的线程可以在 ExecutorService 以并发方式调用另一个线程执行耗时操作的同时，去执行一些其他的任务。接着，如果你已经运行到没有异步操作的结果就无法继续任何有意义的工作时，可以调用它的get 方法去获取操作的结果。如果操作已经完成，该方法会立刻返回操作的结果，否则它会阻塞你的线程，直到操作完成，返回相应的结果。

Feature 使用重载版本的get 方法，它接受一个超时的参数，通过它，你可以定义你的线程等待 Future 结果的最长时间，而不是一直等待下去

使用 CompletableFuture 构建异步应用

我们知道 Future 接口提供了方法来检测异步计算是否已经结束（使用 isDone方法），等待异步操作结束，以及获取计算的结果。但是这些特性还不足以让你编写简洁的并发代码。比如，我们很难表述Future 结果之间的依赖性；从文字描述上这很简单，“当长时间计算任务完成时，请将该计算的结果通知到另一个长时间运行的计算任务，这两个计算任务都完成后，将计算的结果与另一个查询操作结果合并”。但是，使用Future 中提供的方法完成这样的操作又是另外一回事。这也是我们需要更具描述能力的特性的原因，比如下面这些。

 将两个异步计算合并为一个 —— 这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果。

 等待 Future 集合中的所有任务都完成。

 仅等待 Future 集合中最快结束的任务完成（有可能因为它们试图通过不同的方式计算同一个值），并返回它的结果。

 通过编程方式完成一个 Future 任务的执行（即以手工设定异步操作结果的方式）。

 应对 Future 的完成事件（即当 Future 的完成事件发生时会收到通知，并能使用 Future

计算的结果进行下一步的操作，不只是简单地阻塞等待操作的结果）。下面你会了解新的CompletableFuture 类（它实现了 Future 接口）如何利用 Java 8 的新特性以更直观的方式将上述需求都变为可能。Stream 和 CompletableFuture 的设计都遵循

了类似的模式：它们都使用了 Lambda 表达式以及流水线的思想。从这个角度，你可以说 CompletableFuture和 Future 的关系就跟 Stream 和 Collection 的关系一样。

（1）runAsync方法：异步创建一个简单的没有返回值的Future

  ExecutorService executorService = Executors.newCachedThreadPool();

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {

            System.out.println(Thread.currentThread().getName());
        }, executorService);

        System.out.println("主线程: " + Thread.currentThread().getName());
        future.get(2, TimeUnit.SECONDS);

结果：


主线程: main
pool-1-thread-1

（2）supplyAsync方法：异步创建一个有返回值的CompleteFuture

 ExecutorService executorService = Executors.newCachedThreadPool();

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {

            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService);

        System.out.println("主线程: " + Thread.currentThread().getName());
        Integer integer = future.get(2, TimeUnit.SECONDS);
        System.out.println(integer);

结果：


主线程: main
pool-1-thread-1
4

（3）thenApply, thenAccept, thenRun,这三个都是同步操作

thenApply() 监听future返回,调用Future方法对返回值业务逻辑操作,这个操作有返回值,比如转换类型

thenAccept() 监听future返回,调用Consumer处理返回值,处理的结果没有返回值,比如打印结果,返回值为CompletableFuture<void>

thenRun() 监听future返回,然后自己自定义处理，返回值为CompletableFuture<void>

 ExecutorService executorService = Executors.newCachedThreadPool();

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {

            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService).thenApply(f ->{
            
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenApply: + " + f);
            return String.valueOf(f) + "aaa";
        });
        
        CompletableFuture<Void> voidCompletableFuture = future.thenAccept(f -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenAccept: + " + f);
        });

        CompletableFuture<Void> voidCompletableFuture1 = voidCompletableFuture.thenRun(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenRun: + ");
        });

        System.out.println("主线程: " + Thread.currentThread().getName());
        String integer = future.get(2, TimeUnit.SECONDS);
        System.out.println(integer);

pool-1-thread-1
主线程: main
pool-1-thread-1
thenApply: + 4
pool-1-thread-1
thenAccept: + 4aaa
pool-1-thread-1
thenRun: + 
4aaa

（4）thenApplyAsync, thenAcceptAsync, thenRunAsync，同上面三个对应，是异步操作

  ExecutorService executorService = Executors.newCachedThreadPool();

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {

            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService).thenApplyAsync(f ->{

            System.out.println(Thread.currentThread().getName());
            System.out.println("thenApply: + " + f);
            return String.valueOf(f) + "aaa";
        }, executorService);

        CompletableFuture<Void> voidCompletableFuture = future.thenAcceptAsync(f -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenAccept: + " + f);
        }, executorService);

        CompletableFuture<Void> voidCompletableFuture1 = voidCompletableFuture.thenRunAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenRun: + ");
        }, executorService);

        System.out.println("主线程: " + Thread.currentThread().getName());
        String integer = future.get(2, TimeUnit.SECONDS);
        System.out.println(integer);

pool-1-thread-1
pool-1-thread-1
thenApply: + 4
pool-1-thread-1
thenAccept: + 4aaa
主线程: main
pool-1-thread-1
thenRun: + 
4aaa

注意：这里是同一个线程，主要是因为这里线程池我用的是可缓存的线程池，线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。我们可以让线程睡眠一点时间

修改下代码：

ExecutorService executorService = Executors.newCachedThreadPool();

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService).thenApplyAsync(f ->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenApply: + " + f);
            return String.valueOf(f) + "aaa";
        }, executorService);

        CompletableFuture<Void> voidCompletableFuture = future.thenAcceptAsync(f -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenAccept: + " + f);
        }, executorService);

        CompletableFuture<Void> voidCompletableFuture1 = voidCompletableFuture.thenRunAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            System.out.println("thenRun: + ");
        }, executorService);

        System.out.println("主线程: " + Thread.currentThread().getName());
        String integer = future.get(4, TimeUnit.SECONDS);
        voidCompletableFuture.get();
        voidCompletableFuture1.get();
        System.out.println(integer);

主线程: main
pool-1-thread-1
pool-1-thread-2
thenApply: + 4
pool-1-thread-1
thenAccept: + 4aaa
pool-1-thread-2
thenRun: + 
4aaa

可以看到还是存在有些线程已经完成并且被复用了，可以再试试把睡眠时间调整为不一样试试。

（3） thenCompose方法多层结构的future返回一个结果,跟java8的flatmap差不多

 CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService).thenCompose(f -> CompletableFuture.supplyAsync(() -> f + "dddd", executorService));

        System.out.println(stringCompletableFuture.get());

pool-1-thread-2
4dddd

（4）thenCombine与thenAcceptBoth, 合并两个future,thenCombine有返回值，thenAcceptBoth没有返回值

ExecutorService executorService = Executors.newCachedThreadPool();
        CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            return 4;
        }, executorService);
        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
            return 5;
        }, executorService);
        CompletableFuture<Integer> f3 = f1.thenCombine(f2, (s1, s2) -> {
            System.out.println(String.format("%d,%d", s1, s2));
            return s1 + s2;
        });
        System.out.println(f3.get());

        CompletableFuture<Void> f4 = f1.thenAcceptBoth(f2, (s1, s2) -> {
            System.out.println(String.format("%d,%d", s1, s2));
        });
        System.out.println(f4.get());

pool-1-thread-1
pool-1-thread-2
4,5
9
4,5
null

（5） allOf anyOf

allOf CompleteableFuture数组里面全部完成才返回结果

 ExecutorService executorService = Executors.newCachedThreadPool();
        List<CompletableFuture<String>> list = IntStream.rangeClosed(0, 10).mapToObj(i -> CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(i * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "sleep :" + i * 1000 + "s");
            return i + "s";
        }, executorService)).collect(Collectors.toList());
        CompletableFuture<Void> f1 = CompletableFuture.allOf(list.toArray(new CompletableFuture[]{}));
        System.out.println("全部已经完成了！！" + f1.get());

pool-1-thread-1sleep :0s
pool-1-thread-2sleep :1000s
pool-1-thread-3sleep :2000s
pool-1-thread-4sleep :3000s
pool-1-thread-5sleep :4000s
pool-1-thread-6sleep :5000s
pool-1-thread-7sleep :6000s
pool-1-thread-8sleep :7000s
pool-1-thread-9sleep :8000s
pool-1-thread-10sleep :9000s
pool-1-thread-11sleep :10000s
全部已经完成了！！null

anyOf CompleteableFuture数组里面其中一个完成就返回结果

 ExecutorService executorService = Executors.newCachedThreadPool();
        List<CompletableFuture<String>> list = IntStream.rangeClosed(0, 10).mapToObj(i -> CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(i * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "sleep :" + i * 1000 + "s");
            return i + "s";
        }, executorService)).collect(Collectors.toList());
        CompletableFuture<Object> f1 = CompletableFuture.anyOf(list.toArray(new CompletableFuture[]{}));
        System.out.println("其中一个已经完成了！！" + f1.get());

pool-1-thread-1sleep :0s
其中一个已经完成了！！0s

Java8笔记5

CompletableFuture： 组合式异步编程

Future 接口

CompletableFuture：组合式异步编程