CompletableFuture

CompletableFuture与Future有什么不同
开发背景
对比举例
Future实现
CompletableFuture实现
不同点
相同点
CompletableFuture的基本使用
创建一个异步任务
获取任务结果
任务完成后的回调
thenApplyXXX
thenAcceptXXXX
thenRunXXX
whenCompleteXXX
handleXXX
thenComposeXXX
依赖于两个任务的回调
前置两个任务都完成后
thenCombineXXX
thenAcceptBothXXX
runAfterBothXXX
前置任意一个任务完成后
applyToEitherXXX
acceptEitherXXX
runAfterEitherXXX
举例
依赖于多个任务的回调
任意一个完成后–anyOf
所有任务都完成后–allOf
举例
异常处理
API的分类与总结
三种基本任务类型
三种重载方法
分类
源码解析
如何创建一个任务
thenApply是如何执行的
uniApplyStage
封装函数是如何被执行的
函数式接口在哪里被调用
UniApply源码解析
后续任务是如何被调用的
调用者触发执行
前置任务触发
postFire方法
后续任务的后续任务是如何被执行的
postComplete源码分析
stack整理流程图
allOf、anyOf是如何实现的

CompletableFuture与Future有什么不同

开发背景

在使用多线程处理任务时，经常会需要等待某一阶段的任务执行完成之后，根据阶段结果再开启新的异

步任务。

这个逻辑可以使用Future来实现，通过Future的isDone方法或get方法来判断异步任务是否完成或获取

结果。这种方法的问题在于，isDone轮询会消耗CPU资源，并且不能够及时的获取的任务完成的状态；

get方法会使调用的线程阻塞，无法处理后续逻辑。

CompletableFuture提供了回调机制和丰富的Stream API，可以很好的完成异步任务的回调和后续任务

处理。并且CompletableFuture可以很好的描述各个异步任务之间的关系，让逻辑更清晰直观。内部的

无锁并发栈也能够高性能的完成异步任务之间的并行调用。

对比举例

模拟场景：

小白去餐厅吃饭，点了一份西红柿鸡蛋和一碗米饭。点完之后就玩王者等吃饭。

此时服务员开始做米饭，厨师开始炒菜。做好之后由服务员打饭上菜，叫小白吃饭。

Future实现

@Test
public void FutureExample2() throws ExecutionException, InterruptedException
{
ExecutorService waiters = Executors.newFixedThreadPool( 2 );
ExecutorService cookers = Executors.newFixedThreadPool( 2 );
printTimeAndThread("小白进入餐厅");
printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

Future makeRice = waiters.submit(() -> {
ThreadTools.sleepSeconds( 2 );
printTimeAndThread("饭好了");
return "米饭";
});

Future cookDish = cookers.submit(() -> {
ThreadTools.sleepSeconds( 2 );
printTimeAndThread("菜好了");
return "番茄炒蛋";
});

Future getRice = waiters.submit(() -> {
final long start = System.currentTimeMillis();
String rice = makeRice.get();
String dish = cookDish.get();
ThreadTools. sleepSeconds( 2 );
printTimeAndThread(String.format("服务员打饭完成，耗时%d",
System.currentTimeMillis() - start));
return String.format("%s + %s 好了", dish, rice);
});
printTimeAndThread("小白在打王者");
printTimeAndThread(String.format("%s ,小白开吃", getRice.get()));
}

结果

CompletableFuture实现

结果

1634092703854 | main | 小白进入餐厅
1634092703854 | main | 小白点了 番茄炒蛋 + 一碗米饭
1634092703856 | main | 小白在打王者
1634092705874 | pool-2-thread-1 | 菜好了
1634092705874 | pool-1-thread-1 | 饭好了
1634092707884 | pool-1-thread-2 | 服务员打饭完成，耗时 4028
1634092707885 | main | 番茄炒蛋 + 米饭 好了 ,小白开吃

@Test
public void CPExample2() {
printTimeAndThread("小白进入餐厅");
printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

CompletableFuture makeRice = CompletableFuture.supplyAsync(() ->
{
sleepSeconds( 2 );
FutureTaskTest.printTimeAndThread("做米饭");
return "米饭";
});
CompletableFuture makeDish = CompletableFuture.supplyAsync(() ->
{
sleepSeconds( 2 );
printTimeAndThread("厨师炒菜");
return "番茄炒蛋";
});
final CompletableFuture allDone = makeDish.thenCombine(makeRice,
(dish, rice) -> {
final long start = System.currentTimeMillis();
sleepSeconds( 2 );
printTimeAndThread(String.format("服务员打饭完成，耗时%d",
System.currentTimeMillis() - start));
return String.format("%s + %s 好了", dish, rice);
});
printTimeAndThread("小白在打王者");
printTimeAndThread(String.format("%s ,小白开吃", allDone.join()));
}

1634822712205 | main | 小白进入餐厅
1634822712205 | main | 小白点了 番茄炒蛋 + 一碗米饭
1634822712207 | main | 小白在打王者
1634822714221 | ForkJoinPool.commonPool-worker-2 | 厨师炒菜
1634822714221 | ForkJoinPool.commonPool-worker-9 | 做米饭
1634822716229 | ForkJoinPool.commonPool-worker-9 | 服务员打饭完成，耗时 2008
1634822716229 | main | 番茄炒蛋 + 米饭 好了 ,小白开吃

不同点

1. CompletableFuture是在前两个任务完成后，自动调用后续任务的；而Future则阻塞了一个线程，

用来等待前两个任务完成。

2. CompletableFuture获取结果的join方法抛出的是RuntimeException，而get方法抛出的是受检异

常InterruptedException, ExecutionException

3. Future需要显示的指定线程池，而CompletableFuture可以默认使用ForkJoinPool。

4. CompletableFuture可以使用类似Stream表达式的API表现出任务之间的逻辑关系，而Future不能

在语法上直观的表示出这个关系。

相同点

对于逻辑上需要获取异步线程计算结果的任务，二者都可能在获取结果时被阻塞。

CompletableFuture的基本使用

CompletableFuture提供的api，大概可以描述一下几种场景：

1. 创建一个异步任务

2. 获取任务的结果

3. 在一个异步任务完成后执行某个逻辑

4. 在两个任务都完成后执行某个逻辑

5. 在两个任务任意一个完成后执行某个逻辑

6. 任意多个任务都完成后执行某个逻辑

7. 任意多个任务，其中一个完成后执行某个逻辑

创建一个异步任务

CompletableFuture提供了两个API用于开启一个异步任务。分别是使用Runnable接口对象作为参数的

runAsync方法与使用Supplier接口对象对作为参数的supplyAsync方法。两种API的区别就是Runnable

接口与Supplier接口的区别，即runAsync方法没有返回值，而supplyAsync方法有返回值。

两个方法使用默认的ForkJoinPool作为线程池执行异步任务。如果需要指定其他的线程池，可以使用以

下重载API：

使用举例：

public static CompletableFuture runAsync(Runnable runnable)
public static  CompletableFuture supplyAsync(Supplier supplier)

public static CompletableFuture runAsync(Runnable runnable,Executor
executor)
public static  CompletableFuture supplyAsync(Supplier supplier,Executor
executor)

执行结果：

获取任务结果

与Future的区别

CompletableFuture比Future多提供了两种获取结果的方法：getNow与Join。

1. getNow类似于Java8的Stream中的optional.orElse()方法，当结果不存在或没有完成时返回给定的

结果。

2. join与get类似，都会阻塞线程，二者区别在于抛出的异常不同。join可能抛出unchecked

exception，不需要强制try catch。get在方法签名中声明了受检异常，必须要在编码时进行处理。

使用举例

@Test
public void CompletableFutureStart() {
CompletableFuture.runAsync(() -> {
ThreadTools.sleepSeconds( 1 );
System.out.printf("run on %s %n", Thread.currentThread().getName());
});
CompletableFuture.supplyAsync(() -> {
ThreadTools.sleepSeconds( 2 );
System.out.printf("run on %s %n", Thread.currentThread().getName());
return "success";
});
ThreadTools.sleepSeconds( 5 );
}

run on ForkJoinPool.commonPool-worker- 1
run on ForkJoinPool.commonPool-worker- 2

public T get()
public T get(long timeout, TimeUnit unit)
public T getNow(T valueIfAbsent)
public T join()

@Test
public void CompletableFutureGet() {
try {
final Void unused = CompletableFuture.runAsync(() -> {
ThreadTools.sleepSeconds( 1 );
System.out.printf("run on %s %n", Thread.currentThread().getName());
}).get();
System.out.println("CompletableFuture task 1 result "+unused);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}

final String result = CompletableFuture.supplyAsync(() -> {
ThreadTools.sleepSeconds( 2 );
System.out.printf("run on %s %n", Thread.currentThread().getName());
return "success";
}).join();
System.out.println("CompletableFuture task2 result "+result);
ThreadTools.sleepSeconds( 5 );

结果

任务完成后的回调

CompletableFuture的一大特性就是丰富的基于回调的API。当某一个阶段的任务完成后，有时希望能够

及时的获取结果，并操作下一步的逻辑。如果使用Future来实现，那么可能需要阻塞的通过get获取结

果，或不断的通过isDone方法轮询，确认任务是否完成。但使用CompletableFuture，这一切就可以很

自然并高效的完成。并且CompletableFuture的回调对象可以是多个，多个回调对象会被依次回调执

行。

针对与某“一个”任务完成的回调，有多个API可以调用。这些API的区别基本在于入参与返回值，但执行

的时机都是当前阶段的任务完成后。具体如下：

thenApplyXXX

作用：当前阶段（调用该方法的CompletionStage对象）非异常完成时，以 当前阶段的结果为入参 ，执

行给定的函数，函数有返回值。

举例

thenAcceptXXXX

作用：与thenApply类似。当前阶段非异常完成时， 以当前结果为入参 ，执行给定的consumer函数， 函

数没有返回值 。方法返回CompletionStage对象，对象的阶段结果为null。

}

run on ForkJoinPool.commonPool-worker-
CompletableFuture task 1 result null
run on ForkJoinPool.commonPool-worker-
CompletableFuture task2 result success

public  CompletionStage thenApply(Function fn);
public  CompletionStage thenApplyAsync(Function
fn);
public  CompletionStage thenApplyAsync(Function
fn,Executor executor);

@Test
public void RunTest() {
final CompletableFuture future1 = CompletableFuture.supplyAsync(() -
> "from supply").thenApply(r -> {
System.out.println(r);
return "success";
});
System.out.println(future1.join());
}

public CompletionStage thenAccept(Consumer action);
public CompletionStage thenAcceptAsync(Consumer action);
public CompletionStage thenAcceptAsync(Consumer
action,Executor executor);

thenRunXXX

作用：当前阶段非异常完成时，执行制定动作。 没有入参和返回值 。

whenCompleteXXX

作用：当前阶段完成时给定的BiConsumer函数被调用， 入参为抛出的异常（正常结束时为null）和结

果（异常结束时为null） ， 函数无返回值 ，方法返回的CompletionStage对象，含的结果或异常与当前

阶段相同（不改变上一阶段的结果）。

特点：可同时处理正常与异常的情况。

handleXXX

作用：当前阶段完成时给定的BiFunction函数被调用， 入参为抛出的异常（正常结束时为null）和结果

（异常结束时为null） ， 函数有返回值 。返回的CompletionStage对象为函数式接口的结果包装。

thenComposeXXX

作用：当前阶段非异常完成时，执行给定的函数。函数使用当前阶段的结果作为入参， 函数 返回另一个

CompletionStage对象。thenCompose方法会将这个对象展开，避免结果的嵌套。执行效果类似于

Stream中的flatMap。

举例：

public CompletionStage thenRun(Runnable action);
public CompletionStage thenRunAsync(Runnable action);
public CompletionStage thenRunAsync(Runnable action,Executor executor);

public CompletionStage whenComplete(BiConsumer
action);
public CompletionStage whenCompleteAsync(BiConsumer action);
public CompletionStage whenCompleteAsync(BiConsumer action,Executor executor);

public  CompletionStage handle(BiFunction fn);
public  CompletionStage handleAsync(BiFunction fn);
public  CompletionStage handleAsync(BiFunction fn,Executor executor);

public  CompletionStage thenCompose(Function> fn);
public  CompletionStage thenComposeAsync(Function> fn);
public  CompletionStage thenComposeAsync(Function> fn,Executor executor);

/**

* thenCompose举例
*/
@Test

thenCompose结果输出

thenApply结果输出

依赖于两个任务的回调

有时后续的任务可能需要依赖于前两个任务的结果，针对这种情况，CompletableFuture也提供了对应

的API。分为两类，分别是前两个任务都完成，前两个任务任意一个完成后，调用后续任务执行逻辑。具

体如下：

public void FutureTaskTestCompose() {
CompletableFuture future1 = CompletableFuture.supplyAsync(() ->
"task 1");
final CompletableFuture future2 =
CompletableFuture.supplyAsync(() -> "next stage");
CompletableFuture nextFuture = future1.thenCompose((result) -> {
System.out.printf("future1 result is \"%s\"%n", result);
return future2;
});
System.out.println(future2 == nextFuture);
final String join = nextFuture.join();
System.out.printf("nextFuture result is \"%s\"%n", join);
}

/**

* thenCompose对比thenApply
*/
@Test
public void FutureTaskTestCompose2() {
CompletableFuture future1 = CompletableFuture.supplyAsync(() ->
"task 1");
final CompletableFuture future2 =
CompletableFuture.supplyAsync(() -> "next stage");
//thenApply返回一个CompletableFuture对象
final CompletableFuture> nextFuture =
future1.thenApply((result) -> {
System.out.printf("future1 result is \"%s\"%n", result);
return future2;
});
final CompletableFuture innerStage = nextFuture.join();//获取到的
结果为CompletableFuture对象
final String result = innerStage.join();//获取返回的CompletableFuture对象执
行的结果
System.out.printf("nextFuture result is \"%s\"%n", result);
}

future1 result is "task 1"
false
nextFuture result is "next stage"

future1 result is "task 1"
nextFuture result is "next stage"

前置两个任务都完成后

thenCombineXXX

当调用该方法的前置任务与给点的前置任务都完成时，执行BiFunction函数。 函数的入参为前置两阶段

的返回结果，函数无返回值。 阶段的结果CompletableFuture对象中result字段值为函数计算结果。

thenAcceptBothXXX

作用：与thenAccep类似，但依赖于两个阶段。当前阶段与给定的阶段都非异常的执行完成时， 以两个

阶段的结果为入参 ，执行给定的函数， 函数无返回值 。阶段的结果CompletableFuture对象中result字

段值为null。

runAfterBothXXX

作用：与thenRun类似，当前阶段与给点的阶段都异常的完成时，执行给点的函数。 函数无入参，无返

回值 。阶段的结果CompletableFuture对象中result字段值为null。

前置任意一个任务完成后

applyToEitherXXX

作用：当前阶段或给点的阶段任意一个非异常的完成时，执行给定的函数。 以完成阶段的结果作为函数

的入参，函数有返回值。 阶段的结果CompletableFuture对象中result字段值为函数计算结果。

public  CompletionStage thenCombine(CompletionStage
other,BiFunction fn);
public  CompletionStage thenCombineAsync (CompletionStage
other, BiFunction fn);
public  CompletionStage thenCombineAsync (CompletionStage
other, BiFunction fn,Executor executor);

public  CompletionStage thenAcceptBoth(CompletionStage
other,BiConsumer action);
public  CompletionStage thenAcceptBothAsync(CompletionStage other,BiConsumer action);
public  CompletionStage thenAcceptBothAsync(CompletionStage other,BiConsumer action, Executor executor);

public CompletionStage runAfterBoth(CompletionStage other,Runnable
action);
public CompletionStage runAfterBothAsync(CompletionStage other,Runnable
action);
public CompletionStage runAfterBothAsync(CompletionStage other,Runnable
action,Executor executor);

public  CompletionStage applyToEither(CompletionStage
other,Function fn);
public  CompletionStage applyToEitherAsync(CompletionStage
other,Function fn);
public  CompletionStage applyToEitherAsync(CompletionStage
other,Function fn,Executor xecutor);

acceptEitherXXX

作用：同applyToEither。但函数为consumer函数式接口， 无返回值 。

runAfterEitherXXX

作用：同applyToEither。但函数为Runnable接口， 无入参，无返回值。

举例

输出结果

public CompletionStage acceptEither(CompletionStage
other,Consumer action);
public CompletionStage acceptEitherAsync(CompletionStage
other,Consumer action);
public CompletionStage acceptEitherAsync(CompletionStage
other,Consumer action,Executor executor);

public CompletionStage runAfterEither(CompletionStage other,Runnable
action);
public CompletionStage runAfterEitherAsync(CompletionStage
other,Runnable action);
public CompletionStage runAfterEitherAsync(CompletionStage
other,Runnable action,Executor executor);

/**

* 依赖于两个前置任务的API举例

*/

@Test
public void bothOrAny() {

final CompletableFuture task1 = CompletableFuture.supplyAsync(() ->
{
ThreadTools.sleepSeconds( 1 );
return "task 1";
});
final CompletableFuture task2 = CompletableFuture.supplyAsync(() ->
{
ThreadTools.sleepSeconds( 2 );
return "task 2";
});
//依赖于两个前置任务都完成
final CompletableFuture both = task2.thenAcceptBothAsync(task1, (r1,
r2) -> {
System.out.printf("两个任务都已经完成。结果 1 ：%s ,结果2: %s%n", r1, r2);
});
//依赖于两个前置任务，但有一个完成即可
final CompletableFuture any = task1.acceptEitherAsync(task2, (r) -> {
System.out.printf("有一个任务已经完成，结果是：%s%n", r);
});
//阻塞主线程结束
any.runAfterBoth(both, ()->{}).join();
}

依赖于多个任务的回调

除了依赖于一个、两个前置任务的API，更常用的是基于批量任务完成时机的判断。CompletableFuture

也提供了对应的api。

任意一个完成后–anyOf

CompletableFuture提供了静态方法，用来表示当所有的前置任务中，有任意一个任务完成（包括异

常）的阶段。可以在此阶段后执行CompletableFuture的其他操作。

所有任务都完成后–allOf

与anyOf类似，allOf静态方法表示传入的所有前置任务都完成的阶段。可以在此阶段后执行

CompletableFuture的其他操作。

注： 如果异步任务执行异常，也看作是完成状态。

举例

输出结果

有一个任务已经完成，结果是：task 1
两个任务都已经完成。结果 1 ：task 2 ,结果2: task 1

public static CompletableFuture