异步任务编排神器CompletableFuture

原创

菜菜的后端私房菜

发布于 2024-08-15 09:18:57

2370

发布于 2024-08-15 09:18:57

文章被收录于专栏：深入浅出Java并发编程

异步任务编排神器CompletableFuture

当需要获取异步任务的结果时，通常可以通过Future接口的get方法来获取结果

但是当异步任务繁多并且复杂，任务间可能存在依赖关系时，Future接口变得不太好用

比如任务A完成后串行执行任务B，等到B、C任务都完成后执行D任务，等到D、E、F任务都完成后汇总结果返回

当遇到复杂的异步任务编排时，Future不太好用，但是在JDK8中并发包推出的CompletableFuture能够很方便的处理这种异步编排任务

比如在一个页面需要查询多个服务的数据，如果同步查询会导致性能太慢

异步查询多个服务的数据再汇总返回，则能提高更多的性能

API

这里的API只作简单说明，大概分下类，各个分类下具体API的功能可自行查看文档（或者用到时再自行查看文档）

CompletableFuture提供的API大概分为几个大类：

同步与异步、串行、AND、OR、

同步与异步

**API携带Async则说明是异步，并且可以设置线程池**

一般业务开发，CompletableFuture用于处理IO任务，最好使用异步，并且指定线程池

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

            System.out.println("task a run");

            return "a";

});

串行

串行执行指的是任务需要同步执行，如图中的A、B任务，需要A任务执行完才能执行B任务

**串行API通常以then开头**，如：thenRunAsync、thenAccpetAsync、thenApplyAsync

CompletableFuture<String> taskB = taskA.thenApply((s) -> {

    System.out.println("task b run");

    return s + "b";

})

AND

AND指的是需要两个任务都完成，才能继续执行后续的任务，比如图中的B、C任务，要都完成才能执行D任务

**AND相关API通常以Combine、Both有关**，如：thenCombineAsync、thenAcceptBothAsync、runAfterBothAsync

CompletableFuture<String> taskD = taskB.thenCombineAsync(taskC, (b, c) -> {

    System.out.println("task d run");

    return b + c;

})

如果依赖多个任务同时完成，可以使用allOf(如图中的D、F、E任务)

CompletableFuture.allOf(taskF,taskE,taskD);

OR

OR指的是两个任务中其中一个完成，就可以继续执行后续任务

OR相关API通常以Either有关：applyToEitherAsync、acceptEitherAsync、runAfterEitherAsync

如果依赖多个任务的OR时使用：CompletableFuture.anyOf

异常处理

任务执行过程中可能出现异常，可以通过exceptionally 、whenComplete、handler等API对异常进行处理

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

    System.out.println("task f run");

    return "a";

}).exceptionally(e -> {

    System.out.println("出现异常");

    throw new RuntimeException("error");

});

注意事项

使用CompletableFuture时需要注意，如果不了解原理容易踩坑：

比如：任务出了异常怎么办？任务如何选择线程池的？线程又是如何执行的？

带着这一系列问题，我们往下看

出了异常怎么办？

使用CompletableFuture进行异步编排任务时，任务可能出现异常，因此**必须使用API进行处理**

**CompletableFuture遇到异常时，可能会使用CompletionException或ExecutionException包装异常**

public static void exception() {

    CompletableFuture<Void> taskException = CompletableFuture.supplyAsync(() -> {

        System.out.println("begin");

        return null;

    });



    taskException

            .thenApply(result -> {

                int i = 1 / 0;

                return i;

            })

            .exceptionally(err -> {

                //java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero

                System.out.println(err);



                //java.lang.ArithmeticException: / by zero

                System.out.println(err.getCause());



                //java.lang.ArithmeticException: / by zero

                //使用工具处理异常

                System.out.println(getException(err));

                return 0;

            });

    

}

因为异常会被包装，因此处理异常时，**最好使用工具类获取异常**

public static Throwable getException(Throwable throwable) {

    //异常为CompletionException或ExecutionException，并且Cause不为空时解析

    if ((throwable instanceof CompletionException或 || throwable instanceof ExecutionException)

            && Objects.nonNull(throwable.getCause())) {

        return throwable.getCause();

    }

    return throwable;

}

如何选择线程池？

CompletableFuture中选择线程池有三种情况：

**使用方法时指定线程池**
**未指定线程池时，使用ForkJoin的公共线程池 ForkJoinPool.commonPool() (适合CPU任务，最大线程数量 = CPU - 1)**
**未指定线程池时，使用 ThreadPerTaskExecutor 每次执行任务时创建一个线程执行 (适合周期长的任务，创建/销毁线程开销大)**

当未指定线程池时，可能使用ForkJoin的线程池也可能使用ThreadPerTaskExecutor，在没有查看源码的情况下会容易踩坑

并且 ThreadPerTaskExecutor 和 ForkJoinPool.commonPool() 都不适合IO任务

接下来一步步查看源码，分析CompletableFuture什么情况下会选择哪种线程池

CompletableFuture.supplyAsync

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {

    return asyncSupplyStage(asyncPool, supplier);

}

当我们使用未指定线程池的方法时，会直接使用asyncPool作为线程池

private static final Executor asyncPool = useCommonPool ?

    ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

**asyncPool根据useCommonPool来判断是使用 ForkJoinPool.commonPool() 还是使用 ThreadPerTaskExecutor**

那么useCommonPool是如何确定的呢？我们继续往下查看

private static final boolean useCommonPool =

    (ForkJoinPool.getCommonPoolParallelism() > 1);

能否使用useCommonPool，由 ForkJoinPool.getCommonPoolParallelism() 决定，当它大于1时则使用 ForkJoinPool.commonPool() 否则使用 ThreadPerTaskExecutor

ForkJoinPool.getCommonPoolParallelism() 返回字段 commonParallelism

static final int commonParallelism;

commonParallelism 用于表示ForkJoinPool的并行粒度，在ForkJoinPool静态代码块中赋值初始化

ForkJoinPool.static

static {

    //其他略...

    

    //创建公共池

    common = java.security.AccessController.doPrivileged

        (new java.security.PrivilegedAction<ForkJoinPool>() {

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

    

    //计算并行粒度

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

    commonParallelism = par > 0 ? par : 1;

}

commonParallelism 并发粒度的字段由par决定，而par = common.config & SMASK

其中SMASK为65535（十进制），其二进制为全1，因此由 common 的字段 config 决定

（在创建公共池的过程会设置config字段）

ForkJoinPool.makeCommonPool

在创建公共池的代码中主要观察变量 parallelism 它为并发粒度

如果不携带参数，**默认情况下并发粒度为CPU核数-1**

private static ForkJoinPool makeCommonPool() {



    final ForkJoinWorkerThreadFactory commonPoolForkJoinWorkerThreadFactory =

            new CommonPoolForkJoinWorkerThreadFactory();

    //初始化并发粒度为-1

    int parallelism = -1;

    ForkJoinWorkerThreadFactory factory = null;

    UncaughtExceptionHandler handler = null;

    try {  // ignore exceptions in accessing/parsing properties

        String pp = System.getProperty

            ("java.util.concurrent.ForkJoinPool.common.parallelism");

        String fp = System.getProperty

            ("java.util.concurrent.ForkJoinPool.common.threadFactory");

        String hp = System.getProperty

            ("java.util.concurrent.ForkJoinPool.common.exceptionHandler");

        if (pp != null)

            //如果携带启动参数则设置为对应的并发粒度

            parallelism = Integer.parseInt(pp);

        if (fp != null)

            factory = ((ForkJoinWorkerThreadFactory)ClassLoader.

                       getSystemClassLoader().loadClass(fp).newInstance());

        if (hp != null)

            handler = ((UncaughtExceptionHandler)ClassLoader.

                       getSystemClassLoader().loadClass(hp).newInstance());

    } catch (Exception ignore) {

    }

    if (factory == null) {

        if (System.getSecurityManager() == null)

            factory = commonPoolForkJoinWorkerThreadFactory;

        else // use security-managed default

            factory = new InnocuousForkJoinWorkerThreadFactory();

    }

    if (parallelism < 0 && // default 1 less than #cores

        //默认情况下并发粒度 = CPU核数 - 1

        (parallelism = Runtime.getRuntime().availableProcessors() - 1) <= 0)

        parallelism = 1;

    if (parallelism > MAX\_CAP)

        parallelism = MAX\_CAP;

    return new ForkJoinPool(parallelism, factory, handler, LIFO\_QUEUE,

                            "ForkJoinPool.commonPool-worker-");

}

在构建对象时，config字段 this.config = (parallelism & SMASK) | mode

其中SMASK为全1，mode为0，得到的结果是不变的，因此config的值就是parallelism并发粒度

至此我们可以得出结论：**默认情况下，如果不指定线程池，当CPU核数-1超过1则会使用ForkJoin公共池（最大线程数量 = CPU核数 - 1），否则使用ThreadPerTaskExecutor（每次执行都创建线程执行）**

static final class ThreadPerTaskExecutor implements Executor {

    public void execute(Runnable r) { new Thread(r).start(); }

}

ThreadPerTaskExecutor只适合执行周期长的任务，如果任务周期短，并且多的情况下，创建线程也会是很大一笔开销

**使用CompletableFuture时务必指定线程池，线程池最好根据业务做好隔离**

**如果不指定线程池会根据CPU核数选择ForkJoinCommonPool或ThreadPerTaskExecutor，它们并不适合IO任务**

线程如何执行？

在同步与异步的API中线程如何执行？

**在异步的API中，如果指定线程池则交给线程池中的工作线程执行，否则选择Common Pool或ThreadPerTaskExecutor**

**在同步的API中，通常是当前线程进行执行任务，但如果任务B依赖的任务A未完成则由任务A的回调线程执行，任务A如果是异步则由线程池来执行**

public static void testSync() {

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

//            try {

//                Thread.sleep(5000);

//            } catch (InterruptedException e) {

//                throw new RuntimeException(e);

//            }

            return "ok";

        }, threadPool);





        CompletableFuture<Void> taskB = taskA.thenAccept(s -> {

            //任务A执行完（不睡时）由当前线程执行

            //任务A未执行完（睡眠时）由线程池的工作线程执行

            System.out.println(s);

            System.out.println(s);

        });



        taskB.join();

}