java 开发语言 架构 面试 职场和发展 性能优化 线程池 CompletableFuture 详解

了解 Future的同事，都清楚Future没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。同时，获取结果的get()方法也会阻塞当前线程。

CompletableFuture常用方法归类:

分类方法说明返回值异步执行一个线程`runAsync(Runnable)``supplyAsync(Supplier)`默认使用`ForkJoinPool.commonPool`线程池,也可通过`Executor`参数指定线程池`runAsync`无返回值，`supplyAsync`有返回值。调用`get()`,`join()`返回阻塞等待线程结束两个线程一次执行`thenApply`获取前一个线程的结果，进行转换有返回值`thenAccept`获取前一个线程的结果，消费无返回值`thenRun`忽略前一个线程的结果，执行额外的逻辑无返回值`whenComplete`获取前一个线程的结果或异常，消费不影响上一线程的返回值`exceptionally`前面线程异常时执行，一般跟`whenComplete`配合使用。捕获异常范围和前面所有异步线程，如：`thenApply().thenAccept().exceptionally()`有返回值`handle`相当于`whenComplete`和`exceptionally`的组合。根据是否产生异常，内部`if else`分支处理业务逻辑有返回值等待两个线程都执行完`thenCombine`2个线程都要有返回值，等待都结束，结果合并转换有返回值`thenAcceptBoth`2个线程都要有返回值，等待都结束，结果合并消费 无返回值`runAfterBoth`2个线程无需要有返回值，等待都结束，执行其他逻辑无返回值等待两个线程任一执行完`applyToEither`2个线程都要有返回值，等待任一先结束，转换其结果有返回值`acceptToEither`2个线程都要有返回值，等待任一先结束，消费其结果无返回值`runAfterEither`2个线程无需有返回值，等待任一先结束，执行其他逻辑无返回值多个线程等待`CompletableFuture.anyOf(cf1,cf2,cf3).join()`多个任务任一执行完即返回有返回值`Object``CompletableFuture.all(cf1,cf2,cf3).join()`多个任务全部执行完返回无返回值

一、CompletableFuture 介绍

JDK1.8中的CompletableFuture是对Future的扩展和加强。实现了CompletionStage和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力和通过回调的方式处理计算结果，使Java在处理多任务的协同工作时更加顺畅便利。

CompletionStage接口定义了任务编排的方法，可以向下执行后续阶段。异步执行的，默认线程池是ForkJoinPool.commonPool()，但为了业务之间互不影响，且便于定位问题，强烈推荐使用自定义线程池。

CompletableFuture中默认线程池如下：

// 根据commonPool的并行度来选择,而并行度的计算是在ForkJoinPool的静态代码段完成的

private static final boolean useCommonPool =

(ForkJoinPool.getCommonPoolParallelism() > 1);

private static final Executor asyncPool = useCommonPool ?

ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

//forkJoinPool中初始化commonPool的参数

static {

// initialize field offsets for CAS etc

try {

U = sun.misc.Unsafe.getUnsafe();

Class k = ForkJoinPool.class;

CTL = U.objectFieldOffset

(k.getDeclaredField("ctl"));

RUNSTATE = U.objectFieldOffset

(k.getDeclaredField("runState"));

STEALCOUNTER = U.objectFieldOffset

(k.getDeclaredField("stealCounter"));

Class tk = Thread.class;

……

} catch (Exception e) {

throw new Error(e);

}

commonMaxSpares = DEFAULT_COMMON_MAX_SPARES;

defaultForkJoinWorkerThreadFactory =

new DefaultForkJoinWorkerThreadFactory();

modifyThreadPermission = new RuntimePermission("modifyThread");

// 调用makeCommonPool方法创建commonPool,其中并行度为逻辑核数-1

common = java.security.AccessController.doPrivileged

(new java.security.PrivilegedAction() {

public ForkJoinPool run() { return makeCommonPool(); }});

int par = common.config & SMASK; // report 1 even if threads disabled

commonParallelism = par > 0 ? par : 1;

}

二、异步操作

CompletableFuture提供了四个静态方法来创建一个异步操作：

public static CompletableFuture runAsync(Runnable runnable)

public static CompletableFuture runAsync(Runnable runnable, Executor executor)

public static CompletableFuture supplyAsync(Supplier supplier)

public static CompletableFuture supplyAsync(Supplier supplier, Executor executor)

4个方法详解： 【1】runAsync()以Runnable函数式接口类型为参数，没有返回结果，supplyAsync()以Supplier函数式接口类型为参数，返回结果类型为U；Supplier接口的get()是有返回值的(会阻塞) 【2】使用没有指定Executor的方法时，内部使用ForkJoinPool.commonPool()作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行 【3】默认情况下CompletableFuture会使用公共的ForkJoinPool线程池，这个线程池默认创建的线程数是CPU的核数（也可以通过JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism来设置ForkJoinPool线程池的线程数）。如果所有CompletableFuture共享一个线程池，那么一旦有任务执行一些很慢的I/O操作，就会导致线程池中所有线程都阻塞在I/O操作上，从而造成线程饥饿，进而影响整个系统的性能。所以，强烈建议你要根据不同的业务类型创建不同的线程池，以避免互相干扰

异步操作

Runnable runnable = () -> System.out.println("无返回结果异步任务");

CompletableFuture.runAsync(runnable);

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

System.out.println("有返回值的异步任务");

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

return "Hello World";

});

String result = future.get();

join()和get()方法都是用来获取CompletableFuture异步之后的返回值。join()方法抛出的是uncheck异常（即未经检查的异常),不会强制开发者抛出。get()方法抛出的是经过检查的异常，ExecutionException, InterruptedException需要用户手动处理, 抛出或者 try catch

结果处理： 当CompletableFuture的计算结果完成，或者抛出异常的时候，我们可以执行特定的Action。主要是下面的方法：

public CompletableFuture whenComplete(BiConsumer action)

public CompletableFuture whenCompleteAsync(BiConsumer action)

public CompletableFuture whenCompleteAsync(BiConsumer action, Executor executor)

【1】Action的类型是BiConsumer，它可以处理正常的计算结果，或者异常情况 【2】方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行) 【3】这几个方法都会返回CompletableFuture，当Action执行完毕后它的结果返回原始的CompletableFuture的计算结果或者返回异常

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

try {

TimeUnit.SECONDS.sleep(1);

} catch (InterruptedException e) {

}

if (new Random().nextInt(10) % 2 == 0) {

int i = 12 / 0;

}

System.out.println("执行结束！");

return "test";

});

// 任务完成或异常方法完成时执行该方法

// 如果出现了异常,任务结果为null

future.whenComplete(new BiConsumer() {

@Override

public void accept(String t, Throwable action) {

System.out.println(t+" 执行完成！");

}

});

// 出现异常时先执行该方法

future.exceptionally(new Function() {

@Override

public String apply(Throwable t) {

System.out.println("执行失败：" + t.getMessage());

return "异常xxxx";

}

});

future.get();

代码出现异常时，输出结果如下:

执行失败：java.lang.ArithmeticException: / by zero

null 执行完成！

三、链式操作

将上一段任务的执行结果传入下一阶段重新计算，产生新的结果。

thenApply

thenApply接收一个函数作为参数，使用该函数处理上一个CompletableFuture调用的结果，并返回一个具有处理结果的Future对象。

public CompletableFuture thenApply(Function fn)

public CompletableFuture thenApplyAsync(Function fn)

// 具体使用

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

int result = 100;

System.out.println("第一次运算：" + result);

return result;

}).thenApply(number -> {

int result = number * 3;

System.out.println("第二次运算：" + result);

return result;

});

thenCompose

thenCompose的参数为一个返回CompletableFuture实例的函数，该函数的参数是先前计算步骤的结果。

public CompletableFuture thenCompose(Function> fn);

public CompletableFuture thenComposeAsync(Function> fn) ;

// 具体使用

CompletableFuture future = CompletableFuture

.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(30);

System.out.println("第一次运算：" + number);

return number;

}

})

.thenCompose(new Function>() {

@Override

public CompletionStage apply(Integer param) {

return CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = param * 2;

System.out.println("第二次运算：" + number);

return number;

}

});

}

});

thenApply 和 thenCompose的区别： 【1】thenApply转换的是泛型中的类型，返回的是同一个CompletableFuture 【2】thenCompose将内部的CompletableFuture调用展开来并使用上一个CompletableFutre调用的结果在下一步的CompletableFuture调用中进行运算，是生成一个新的CompletableFuture

四、消费结果

与上述返回新的CompletableFuture不同，结果消费系列函数只对结果执行Action，而不返回新的计算值

thenAccept

对单个结果进行消费，观察该系列函数的参数类型可知，它们是函数式接口Consumer，这个接口只有输入，没有返回值。

public CompletionStage thenAccept(Consumer action);

public CompletionStage thenAcceptAsync(Consumer action);

// 使用

CompletableFuture future = CompletableFuture

.supplyAsync(() -> {

int number = new Random().nextInt(10);

System.out.println("第一次运算：" + number);

return number;

}).thenAccept(number ->

System.out.println("第二次运算：" + number * 5));

thenAcceptBoth

thenAcceptBoth函数的作用是，当两个CompletionStage都正常完成计算的时候，就会执行提供的action消费两个异步的结果。

public CompletionStage thenAcceptBoth(CompletionStage other,BiConsumer action);

public CompletionStage thenAcceptBothAsync(CompletionStage other,BiConsumer action);

// 使用

CompletableFuture futrue1 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(3) + 1;

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务1结果：" + number);

return number;

}

});

CompletableFuture future2 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(3) + 1;

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务2结果：" + number);

return number;

}

});

futrue1.thenAcceptBoth(future2, new BiConsumer() {

@Override

public void accept(Integer x, Integer y) {

System.out.println("最终结果：" + (x + y));

}

});

thenRun

thenRun也是对线程任务结果的一种消费函数，与thenAccept不同的是，thenRun会在上一阶段CompletableFuture计算完成的时候执行一个Runnable，而Runnable并不使用该CompletableFuture计算的结果。

public CompletionStage thenRun(Runnable action);

public CompletionStage thenRunAsync(Runnable action);

// 使用

CompletableFuture futrue1 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(3) + 1;

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务1结果：" + number);

return number;

}

});

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

int number = new Random().nextInt(10);

System.out.println("第一阶段：" + number);

return number;

}).thenRun(() -> System.out.println("thenRun 执行"));

五、组合结果

thenCombine

合并两个线程任务的结果，并进一步处理。

public CompletableFuture thenCombine(CompletionStage other,BiFunction fn);

public CompletableFuture thenCombineAsync(CompletionStage other,BiFunction fn);

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

// 使用

CompletableFuture future1 = CompletableFuture

.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10);

System.out.println("任务1结果：" + number);

return number;

}

});

CompletableFuture future2 = CompletableFuture

.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10);

System.out.println("任务2结果：" + number);

return number;

}

});

CompletableFuture result = future1

.thenCombine(future2, new BiFunction() {

@Override

public Integer apply(Integer x, Integer y) {

return x + y;

}

});

System.out.println("组合后结果：" + result.get());

六、任务交互

线程交互指将两个线程任务获取结果的速度相比较，按一定的规则进行下一步处理。

applyToEither

两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的转化操作。

public CompletionStage applyToEither(CompletionStage other,Function fn);

public CompletionStage applyToEitherAsync(CompletionStage other,Function fn);

CompletableFuture future1 = CompletableFuture

.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10);

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务1结果:" + number);

return number;

}

});

CompletableFuture future2 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10);

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务2结果:" + number);

return number;

}

});

future1.applyToEither(future2, new Function() {

@Override

public Integer apply(Integer number) {

System.out.println("最快结果：" + number);

return number * 2;

}

});

acceptEither

两个线程任务相比较，先获得执行结果的，就对该结果进行下一步的消费操作。

public CompletionStage acceptEither(CompletionStage other,Consumer action);

public CompletionStage acceptEitherAsync(CompletionStage other,Consumer action);

CompletableFuture future1 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10) + 1;

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("第一阶段：" + number);

return number;

}

});

CompletableFuture future2 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(10) + 1;

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("第二阶段：" + number);

return number;

}

});

future1.acceptEither(future2, new Consumer() {

@Override

public void accept(Integer number) {

System.out.println("最快结果：" + number);

}

});

runAfterEither

两个线程任务相比较，有任何一个执行完成，就进行下一步操作，不关心运行结果。

public CompletionStage runAfterEither(CompletionStage other,Runnable action);

public CompletionStage runAfterEitherAsync(CompletionStage other,Runnable action);

CompletableFuture future1 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(5);

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务1结果：" + number);

return number;

}

});

CompletableFuture future2 = CompletableFuture.supplyAsync(new Supplier() {

@Override

public Integer get() {

int number = new Random().nextInt(5);

try {

TimeUnit.SECONDS.sleep(number);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("任务2结果:" + number);

return number;

}

});

future1.runAfterEither(future2, new Runnable() {

@Override

public void run() {

System.out.println("已经有一个任务完成了");

}

}).join();

anyOf

anyOf()的参数是多个给定的CompletableFuture，当其中的任何一个完成时，方法返回这个CompletableFuture。

public static CompletableFuture