Java异步任务CompletableFuture的使用

已于 2024-08-05 10:42:32 修改
阅读量155 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java 文章标签： tomcat 服务器 java
于 2022-03-31 14:28:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42789698/article/details/123870762

文章目录

Java异步任务CompletableFuture的使用

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

一、创建异步任务

1、Future.submit

通常的线程池接口类ExecutorService，其中execute方法的返回值是void，即无法获取异步任务的执行状态，3个重载的submit方法的返回值是Future，可以据此获取任务执行的状态和结果，示例如下：

    @Test
    public void test3() throws Exception {
        // 创建异步执行任务:
        ExecutorService executorService= Executors.newSingleThreadExecutor();
        Future<Double> cf = executorService.submit(()->{
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成,如果已完成则直接返回结果
        //如果执行任务异常，则get方法会把之前捕获的异常重新抛出
        System.out.println("run result->"+cf.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

执行结果如下：

在这里插入图片描述
子线程是异步执行的，主线程休眠等待子线程执行完成，子线程执行完成后唤醒主线程，主线程获取任务执行结果后退出。

很多博客说使用不带等待时间限制的get方法时，如果子线程执行异常了会导致主线程长期阻塞，这其实是错误的，子线程执行异常时其异常会被捕获，然后修改任务的状态为异常结束并唤醒等待的主线程，get方法判断任务状态发生变更，就终止等待了，并抛出异常，可参考《Java8 AbstractExecutorService 和 FutureTask 源码解析》中FutureTask的实现。将上述用例中if(false)改成if(true) ，执行结果如下：

在这里插入图片描述
get方法抛出异常导致主线程异常终止。

2、supplyAsync / runAsync

supplyAsync表示创建带返回值的异步任务的，相当于ExecutorService submit(Callable task) 方法，runAsync表示创建无返回值的异步任务，相当于ExecutorService submit(Runnable task)方法，这两方法的效果跟submit是一样的，测试用例如下：

    @Test
    public void test2() throws Exception {
        // 创建异步执行任务，有返回值
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(true){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
 
   @Test
    public void test4() throws Exception {
        // 创建异步执行任务，无返回值
        CompletableFuture cf = CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
            }
        });
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

这两方法各有一个重载版本，可以指定执行异步任务的Executor实现，如果不指定，默认使用ForkJoinPool.commonPool()，如果机器是单核的，则默认使用ThreadPerTaskExecutor，该类是一个内部类，每次执行execute都会创建一个新线程。测试用例如下：

   @Test
    public void test2() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(true){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        },pool);
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
 
@Test
    public void test4() throws Exception {
        ExecutorService executorService= Executors.newSingleThreadExecutor();
        // 创建异步执行任务:
        CompletableFuture cf = CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
            }
        },executorService);
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

二、异步回调

1、thenApply / thenApplyAsync

thenApply 表示某个任务执行完成后执行的动作，即回调方法，会将该任务的执行结果即方法返回值作为入参传递到回调方法中，测试用例如下：

@Test
    public void test5() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        },pool);
        //cf关联的异步任务的返回值作为方法入参，传入到thenApply的方法中
        //thenApply这里实际创建了一个新的CompletableFuture实例
        CompletableFuture<String> cf2=cf.thenApply((result)->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return "test:"+result;
        });
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread start cf2.get(),time->"+System.currentTimeMillis());
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其执行结果如下：
在这里插入图片描述
job1执行结束后，将job1的方法返回值作为入参传递到job2中并立即执行job2。thenApplyAsync与thenApply的区别在于，前者是将job2提交到线程池中异步执行，实际执行job2的线程可能是另外一个线程，后者是由执行job1的线程立即执行job2，即两个job都是同一个线程执行的。将上述测试用例中thenApply改成thenApplyAsync后，执行结果如下：
在这里插入图片描述
从输出可知，执行job1和job2是两个不同的线程。thenApplyAsync有一个重载版本，可以指定执行异步任务的Executor实现，如果不指定，默认使用ForkJoinPool.commonPool()。 下述的多个方法，每个方法都有两个以Async结尾的方法，一个使用默认的Executor实现，一个使用指定的Executor实现，不带Async的方法是由触发该任务的线程执行该任务，带Async的方法是由触发该任务的线程将任务提交到线程池，执行任务的线程跟触发任务的线程不一定是同一个。

2、thenAccept / thenRun

thenAccept 同 thenApply 接收上一个任务的返回值作为参数，但是无返回值；thenRun 的方法没有入参，也买有返回值，测试用例如下：

@Test
    public void test6() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        },pool);
        //cf关联的异步任务的返回值作为方法入参，传入到thenApply的方法中
        CompletableFuture cf2=cf.thenApply((result)->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return "test:"+result;
        }).thenAccept((result)-> { //接收上一个任务的执行结果作为入参，但是没有返回值
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(result);
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
        }).thenRun(()->{ //无入参，也没有返回值
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("thenRun do something");
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("run result->"+cf.get());
        System.out.println("main thread start cf2.get(),time->"+System.currentTimeMillis());
        //cf2 等待最后一个thenRun执行完成
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其执行结果如下：
在这里插入图片描述

3、 exceptionally

exceptionally方法指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中，如果该任务正常执行则会exceptionally方法返回的CompletionStage的result就是该任务正常执行的结果，测试用例如下：

@Test
    public void test2() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(true){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        },pool);
        //cf执行异常时，将抛出的异常作为入参传递给回调方法
        CompletableFuture<Double> cf2= cf.exceptionally((param)->{
             System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("error stack trace->");
            param.printStackTrace();
            System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
             return -1.1;
        });
        //cf正常执行时执行的逻辑，如果执行异常则不调用此逻辑
        CompletableFuture cf3=cf.thenAccept((param)->{
            System.out.println(Thread.currentThread()+"job2 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("param->"+param);
            System.out.println(Thread.currentThread()+"job2 exit,time->"+System.currentTimeMillis());
        });
        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成,此处无论是job2和job3都可以实现job2退出，主线程才退出，如果是cf，则主线程不会等待job2执行完成自动退出了
        //cf2.get时，没有异常，但是依然有返回值，就是cf的返回值
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其输出如下：
在这里插入图片描述
抛出异常后，只有cf2执行了，cf3没有执行。将上述示例中的if(true) 改成if(false)，其输出如下：
在这里插入图片描述
cf2没有指定，其result就是cf执行的结果，理论上cf2.get应该立即返回的，此处是等待了cf3，即job2执行完成后才返回，具体原因且待下篇源码分析时再做探讨。

4、whenComplete

whenComplete是当某个任务执行完成后执行的回调方法，会将执行结果或者执行期间抛出的异常传递给回调方法，如果是正常执行则异常为null，回调方法对应的CompletableFuture的result和该任务一致，如果该任务正常执行，则get方法返回执行结果，如果是执行异常，则get方法抛出异常。测试用例如下：

@Test
    public void test10() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<Double> cf2=cf.whenComplete((a,b)->{
            System.out.println(Thread.currentThread()+"job2 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
            System.out.println(Thread.currentThread()+"job2 exit,time->"+System.currentTimeMillis());
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->"+System.currentTimeMillis());
        //如果cf是正常执行的，cf2.get的结果就是cf执行的结果
        //如果cf是执行异常，则cf2.get会抛出异常
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

执行结果如下：
在这里插入图片描述
将上述示例中的if(false) 改成if(true)，其输出如下：
在这里插入图片描述

5、handle

跟whenComplete基本一致，区别在于handle的回调方法有返回值，且handle方法返回的CompletableFuture的result是回调方法的执行结果或者回调方法执行期间抛出的异常，与原始CompletableFuture的result无关了。测试用例如下：

 @Test
    public void test10() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(true){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<String> cf2=cf.handle((a,b)->{
            System.out.println(Thread.currentThread()+"job2 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
            System.out.println(Thread.currentThread()+"job2 exit,time->"+System.currentTimeMillis());
            if(b!=null){
                return "run error";
            }else{
                return "run succ";
            }
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->"+System.currentTimeMillis());
        //get的结果是cf2的返回值，跟cf没关系了
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其执行结果如下：
在这里插入图片描述
将上述示例中的if(true) 改成if(false)，其输出如下：
在这里插入图片描述

三、组合处理

1、thenCombine / thenAcceptBoth / runAfterBoth

这三个方法都是将两个CompletableFuture组合起来，只有这两个都正常执行完了才会执行某个任务，区别在于，thenCombine会将两个任务的执行结果作为方法入参传递到指定方法中，且该方法有返回值；thenAcceptBoth同样将两个任务的执行结果作为方法入参，但是无返回值；runAfterBoth没有入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果。测试用例如下：

@Test
    public void test7() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<Double> cf3=cf.thenCombine(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            System.out.println("job3 param a->"+a+",b->"+b);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return a+b;
        });
 
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.thenAcceptBoth(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param a->"+a+",b->"+b);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });
 
        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterBoth(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });
 
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其运行结果如下：
在这里插入图片描述
job1 和 job2几乎同时运行，job2比job1先执行完成，等job1退出后，job3和job4几乎同时开始运行，job4先退出，等job3执行完成，job5开始了，等job5执行完成后，主线程退出。

2、applyToEither / acceptEither / runAfterEither

这三个方法都是将两个CompletableFuture组合起来，只要其中一个执行完了就会执行某个任务，其区别在于applyToEither会将已经执行完成的任务的执行结果作为方法入参，并有返回值；acceptEither同样将已经执行完成的任务的执行结果作为方法入参，但是没有返回值；runAfterEither没有方法入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果。测试用例如下：

@Test
    public void test8() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<Double> cf3=cf.applyToEither(cf2,(result)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            System.out.println("job3 param result->"+result);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return result;
        });
 
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.acceptEither(cf2,(result)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param result->"+result);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });
 
        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterEither(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });
 
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其运行结果如下：
在这里插入图片描述
job1 和job2 同时开始运行，job2先执行完成，然后job4开始执行，理论上job3和job4应该同时开始运行，但是此时只有job4开始执行了，job3是等待job1执行完成后才开始执行，job4先于job3执行完成，然后job5开始执行，等job5执行完成后，主线程退出。上述差异且到下篇源码分析时再做探讨。

3、thenCompose

thenCompose方法会在某个任务执行完成后，将该任务的执行结果作为方法入参然后执行指定的方法，该方法会返回一个新的CompletableFuture实例，如果该CompletableFuture实例的result不为null，则返回一个基于该result的新的CompletableFuture实例；如果该CompletableFuture实例为null，则，然后执行这个新任务，测试用例如下：

    @Test
    public void test9() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<String> cf2= cf.thenCompose((param)->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return CompletableFuture.supplyAsync(()->{
                System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
                return "job3 test";
            });
        });
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf2.get(),time->"+System.currentTimeMillis());
        System.out.println("cf2 run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其输出如下：
在这里插入图片描述
job1执行完成后job2开始执行，等job2执行完成后会把job3返回，然后执行job3，等job3执行完成后，主线程退出。

4、allOf / anyOf

allOf返回的CompletableFuture是多个任务都执行完成后才会执行，只有有一个任务执行异常，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回null。

 @Test
    public void test11() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        CompletableFuture<Double> cf3 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1300);
            } catch (InterruptedException e) {
            }
//            throw new RuntimeException("test");
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return 2.2;
        });
        //allof等待所有任务执行完成才执行cf4，如果有一个任务异常终止，则cf4.get时会抛出异常，都是正常执行，cf4.get返回null
        //anyOf是只有一个任务执行完成，无论是正常执行或者执行异常，都会执行cf4，cf4.get的结果就是已执行完成的任务的执行结果
        CompletableFuture cf4=CompletableFuture.allOf(cf,cf2,cf3).whenComplete((a,b)->{
           if(b!=null){
               System.out.println("error stack trace->");
               b.printStackTrace();
           }else{
               System.out.println("run succ,result->"+a);
           }
        });
 
        System.out.println("main thread start cf4.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf4 run result->"+cf4.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }

其输出如下：
在这里插入图片描述
主线程等待最后一个job1执行完成后退出。anyOf返回的CompletableFuture是多个任务只要其中一个执行完成就会执行，其get返回的是已经执行完成的任务的执行结果，如果该任务执行异常，则抛出异常。将上述测试用例中allOf改成anyOf后，其输出如下：
在这里插入图片描述

本人在使用CompletableFuture时遇到的情况

1、所有的CompletableFuture对象创建了之后，执行join或get命令之前，如果我们给他传递了一个对象参数，则他们都会使用同一个对象，所以当给不同的CompletableFuture传递参数的时候，需要创建不同的对象。

/**
     * 异步调用api接口
     * @param apiId
     * @param requestParams
     * @return
     */
    public CompletableFuture<Map<String, Object>> callApiAsync(LoginUser loginUser, String apiId, Map<String, String[]> requestParams) {
        CompletableFuture<Map<String, Object>> future = CompletableFuture.supplyAsync(()->{
            return callApi(loginUser, apiId, requestParams);
        });
        // 异步完成执行方法
        future.whenCompleteAsync((dataMap, throwable) -> {
            System.out.println("apiId: " + apiId);
            for (Map.Entry<String, String[]> entry: requestParams.entrySet()) {
                System.out.println("requestParamsKey: " + entry.getKey());
                System.out.println("requestParamsValue: " + entry.getValue()[0]);
            }
            // 打印一下返回的数据
            JSONArray jsonArray = getCallApiDataToJSONArray(dataMap);
            if (jsonArray.size() > 0) {
                JSONObject jsonObject = jsonArray.getJSONObject(0);
                System.out.println("jsonObject: "+ jsonObject);
            }
        });
        return future;
    }

@Override
    public Map<String, Object> getHomePageDataV2Async(String identityCard, String isQuery) {
        HashMap<String, Object> resultMap = new HashMap<>();
        LoginUser loginUser = SecurityUtils.getLoginUser();
        // 异步获取人物关系图谱，在最后获取数据
        CompletableFuture<Map<String, Object>> personRelationFuture = getPersonRelationshipGraphsAsync(loginUser, identityCard);
        // 调用api接口获取的所有数据map，键为：apiId，值为调用ApiId获取的数据列表
        HashMap<String, JSONArray> apiInfoDataMaps = new HashMap<>();
        // 首页api接口信息数据
        HashMap<String, BusApiInfo> homePageApiInfoMaps = new HashMap<>();
        // 首页api接口返回值数据
        HashMap<String, List<BusApiResultInfo>> homePageResultInfoMaps = new HashMap<>();
        // 排除的api接口
        List<String> excluedApiIds = Arrays.asList(new String[]{"1", "4", "5"});
        // 获取当前查询的身份证的常住人口基本信息
        HashMap<String, String[]> czrkRequestMap = new HashMap<>();
        czrkRequestMap.put("SFHM", new String[]{identityCard});
        // 阻塞获取常住人口数据
        Map<String, Object> czrkxxDataMap = callApi(loginUser, "1", czrkRequestMap);
        JSONArray czrkxxDataList = getCallApiDataToJSONArray(czrkxxDataMap);
        if (CollectionUtils.isEmpty(czrkxxDataList)) {
            czrkxxDataList = new JSONArray();
        }
        // 获取户号，根据户号查询户口信息
        String HH = "";
        if (czrkxxDataList != null && czrkxxDataList.size() > 0) {
            HH = czrkxxDataList.getJSONObject(0).getString("HH");
        }
        // 异步获取照片信息
        HashMap<String, String[]> zpxxRequestMap = new HashMap<>();
        zpxxRequestMap.put("gmsfhm", new String[]{identityCard});
        CompletableFuture<Map<String, Object>> czrkzpxxDataMapFuture = callApiAsync(loginUser, "4", zpxxRequestMap);

        // 异步根据HH查询户口信息
        HashMap<String, String[]> hkxxRequestMap = new HashMap<>();
        hkxxRequestMap.put("HH", new String[]{HH});
        CompletableFuture<Map<String, Object>> hkxxDataMapFuture = callApiAsync(loginUser, "5", hkxxRequestMap);

        // 查询首页所有的api接口
        BusApiInfo queryApiInfo = new BusApiInfo();
        queryApiInfo.setIsHome("Y");
        // 分页加排序，这里是全部查询
        PageHelper.startPage(1, 10000, "sort");
        List<BusApiInfo> homePageApiInfos = selectBusApiInfoList(queryApiInfo);
        // 获取czrk异步操作对象
        CompletableFuture<JSONArray> czrkListFuture = null;
        // 查询户口人员的相关信息
        if (StringUtils.isNotEmpty(isQuery) && "yes".equals(isQuery.toLowerCase())) {
            // 异步获取所有户口人员的常住人口信息
            czrkListFuture = hkxxDataMapFuture.thenApplyAsync((hkxxDataMap) -> {
                JSONArray hkxxDataList = getCallApiDataToJSONArray(hkxxDataMap);
                List<CompletableFuture<Map<String, Object>>> czrkFutures = new ArrayList<>();
                JSONArray resultList = new JSONArray();
                if (CollectionUtils.isEmpty(hkxxDataList)) {
                    hkxxDataList = new JSONArray();
                }
                for (int i = 0; i < hkxxDataList.size(); i++) {
                    // 获取户口人员信息
                    JSONObject hkxxJObj = hkxxDataList.getJSONObject(i);
                    // 找到不是当前身份证号码的人员，获取其常住人口信息
                    String sfhm = hkxxJObj.getString("SFHM");
                    if (!identityCard.equals(sfhm)) {
                        // 调用常住人口接口的api
                        HashMap<String, String[]> czrkRequestMap2 = new HashMap<>();
                        czrkRequestMap2.put("SFHM", new String[]{sfhm});
                        // 异步获取户口人员的常住人口信息
                        CompletableFuture<Map<String, Object>> czrkxxFuture = callApiAsync(loginUser, "1", czrkRequestMap2);
                        czrkFutures.add(czrkxxFuture);
                    }
                }
                for (int i = 0; i < czrkFutures.size(); i++) {
                    JSONArray czrkxxList = getCallApiDataToJSONArray(czrkFutures.get(i).join());
                    resultList.addAll(czrkxxList);
                }
                return resultList;
            });
        }
        if (!ObjectUtils.isEmpty(czrkListFuture)) {
            JSONArray czrkList = czrkListFuture.join();
            if (!CollectionUtils.isEmpty(czrkList)) {
                czrkxxDataList.addAll(czrkList);
            }
        }
        // 遍历所有的api接口
        for (BusApiInfo busApiInfo : homePageApiInfos) {
            String apiId = busApiInfo.getId();
            // 将常住人口接口信息插入
            if ("1".equals(apiId)) {
                homePageApiInfoMaps.put(apiId, busApiInfo);
                // 查询返回值
                List<BusApiResultInfo> busApiResultInfos = busApiResultInfoService.selectBusApiResultInfoListByApiId(apiId);
                homePageResultInfoMaps.put(apiId, busApiResultInfos);
            }
            // 不查询排除掉的api接口
            if (!excluedApiIds.contains(apiId)) {
                homePageApiInfoMaps.put(apiId, busApiInfo);
                // 查询返回值
                List<BusApiResultInfo> busApiResultInfos = busApiResultInfoService.selectBusApiResultInfoListByApiId(apiId);
                homePageResultInfoMaps.put(apiId, busApiResultInfos);
                // 获取其查询参数
                List<BusApiParamInfo> busApiParamInfos = busApiParamInfoService.selectBusApiParamInfoListByApiId(busApiInfo.getId());
                // 遍历常住人口信息列表
                List<CompletableFuture<Map<String, Object>>> apiInfoFutures = new ArrayList<>();
                for (int i = 0; i < czrkxxDataList.size(); i++) {
                    // 获取每条常住人口信息
                    JSONObject czrkxxJObj = czrkxxDataList.getJSONObject(i);
                    // 构建查询map
                    HashMap<String, String[]> queryMap = new HashMap<>();
                    // 遍历参数
                    for (BusApiParamInfo busApiParamInfo : busApiParamInfos) {
                        // 获取参数的备注信息
                        String remark = busApiParamInfo.getRemark();
                        // 根据备注信息，查看常住人口信息有没有这个属性
                        if (StringUtils.isNotEmpty(remark) && czrkxxJObj.containsKey(remark.toUpperCase())) {
                            queryMap.put(busApiParamInfo.getParamName(), new String[]{czrkxxJObj.getString(remark.toUpperCase())});
                        }
                    }
                    // 异步调用接口，获取数据
                    CompletableFuture<Map<String, Object>> apiInfoFuture = callApiAsync(loginUser, apiId, queryMap);
                    apiInfoFutures.add(apiInfoFuture);
                }
                for (int i = 0; i < apiInfoFutures.size(); i++) {
                    JSONArray apiInfoDataList = getCallApiDataToJSONArray(apiInfoFutures.get(i).join());
                    // 如果为空，表示还没有数据，则直接put
                    if (ObjectUtils.isEmpty(apiInfoDataMaps.get(apiId))) {
                        if (!CollectionUtils.isEmpty(apiInfoDataList)) {
                            apiInfoDataMaps.put(apiId, apiInfoDataList);
                        }
                    } else {
                        if (!CollectionUtils.isEmpty(apiInfoDataList)) {
                            apiInfoDataMaps.get(apiId).addAll(apiInfoDataList);
                        }
                    }
                }
            }

        }

        // 人员关系图谱数据构建
        Map<String, Object> personRelationshipGraphs = personRelationFuture.join();
        for (Map.Entry<String, Object> entry : personRelationshipGraphs.entrySet()) {
            resultMap.put(entry.getKey(), entry.getValue());
        }
        // 照片数据构建
        Map<String, Object> czrkzpxxDataMap = czrkzpxxDataMapFuture.join();
        JSONArray czrkzpxxDataList = getCallApiDataToJSONArray(czrkzpxxDataMap);
        if (CollectionUtils.isEmpty(czrkzpxxDataList)) {
            czrkzpxxDataList = new JSONArray();
        }
        // 户口数据构建
        Map<String, Object> hkxxDataMap = hkxxDataMapFuture.join();
        JSONArray hkxxDataList = getCallApiDataToJSONArray(hkxxDataMap);

        apiInfoDataMaps.put("1", czrkxxDataList);
        resultMap.put("czrkxxDataList", czrkxxDataList);
        resultMap.put("hkxxDataList", hkxxDataList);
        resultMap.put("czrkzpxxDataList", czrkzpxxDataList);
        resultMap.put("apiInfoDataMaps", apiInfoDataMaps);
        resultMap.put("homePageApiInfoMaps", homePageApiInfoMaps);
        resultMap.put("homePageResultInfoMaps", homePageResultInfoMaps);
        return resultMap;
    }
Java-CompletableFuture与ExecutorService配合使用
兴趣是最好的老师
08-24 257
下面是一个具体的例子，展示如何使用 CompletableFuture 和 ExecutorService 来实现异步任务的。CompletableFuture 可以与 ExecutorService 配合使用，这样可以在后台线程中执行任务，并在主。首先，我们需要创建一个 ExecutorService 实例，用于执行后台任务。这种方式非常适合处理异步任务，特别是当这些任务涉及到耗时操作（例如 I/O。CompletableFuture 来提交任务并在主线程中获取结果。操作、网络请求等）时。
Java8 CompletableFuture 用法全解
热门推荐
菜鸟进阶之路
05-15 11万+
目录 一、创建异步任务 1、Future.submit 2、supplyAsync /runAsync 二、异步回调 1、thenApply /thenApplyAsync 2、thenAccept /thenRun 3、exceptionally 4、whenComplete 5、handle 三、组合处理 1、thenCombine /thenAcceptBoth /runAfterBoth 2、applyToEither /acceptEither /run...
Java中CompletableFuture的用法
最新发布
m0_51934959的博客
07-16 384
本文详细介绍了Java8中CompletableFuture的使用方法，主要内容包括：1）基本概念和创建方式；2）异步任务执行runAsync/supplyAsync；3）回调处理thenApply/thenAccept/thenRun；4）异常处理exceptionally/handle/whenComplete；5）任务组合方法thenCompose/thenCombine/allOf/anyOf；6）自定义线程池配置。文章通过完整代码示例展示了如何构建异步流程、处理异常以及组合多个任务结果，帮助开发者
Java异步编程利器：CompletableFuture实战
CoderJia的学习之路
12-20 1249
在现代 Java 应用程序开发中，异步编程已经成为提升系统性能和用户体验的重要手段。CompletableFuture 作为 Java 8 引入的异步编程工具，不仅提供了 Future 接口的增强版本，还支持函数式编程，使得异步任务的编排和组合变得更加灵活和直观。本文将深入探讨 CompletableFuture 的各种应用场景，帮助你更好地掌握这个强大的工具。
Java 异步编程进阶：CompletableFuture 完全指南
dazhong2012的专栏
04-19 3122
CompletableFuture 是 Java 8 引入的一个类，用于异步编程。它实现了 Future 接口，并添加了许多额外的方法，使得异步编程更加灵活和强大。与传统的 Future 相比，CompletableFuture 允许我们显式地完成一个异步任务，而不必等待其完成。
Java异步编程CompletableFuture(串行,并行,批量执行)
总结分享
11-11 4257
使用CompletableFuture可以简化异步编程的复杂性，并提供更灵活和强大的功能。它是Java 8中新增的功能之一，为开发者提供了更好的异步编程体验。
JAVA异步任务-CompletableFuture
qq_33479841的博客
10-14 993
在jdk1.8中，引入了CompletableFuture，它扩展了Future和CompletionStage，可以在任务完成后触发回调，实现异步调用。在此之前若要设置回调一般会使用guava的ListenableFuture，但引入回调之后会陷入无穷的回调地狱中，导致编码难以阅读和理解。CompletableFuture对Future进行了扩展，可以通过设置回调的方式处理计算结果，同时也支持组合，支持任务编排，在一定程度上解决了回调地狱和代码难以阅读问题。
Java 异步执行 CompletableFuture
09-03 1239
2023-05-10T10:40:02.917+08:00 INFO 96282 --- [onPool-worker-2] c.n.c.test.TestThreadController : ForkJoinPool.commonPool-worker-2 - 接着执行第二个 thenApplyAsync 任务。System.out.println(Thread.currentThread().getName() + " - 接着执行第二个 thenRunAsync 任务");
Java8中CompletableFuture详解
Life is for sharing的博客
09-25 2488
文章目录1.定义2.supplyAsync2.1supplyAsync(Supplier)2.2supplyAsync(Supplier, Executor)3.runAsync3.1runAsync(Runnable)3.2runAsync(Runnable, Executor)4.completedFuture5.isDone6.get6.1get()6.2get(long, TimeUnit...
【JAVA8】CompletableFuture使用详解
胖虎儿的博客
08-22 1万+
CompletableFuture！让你的代码免受阻塞之苦！ 灵活的使用`CompletableFuture`可以让我们感受java8的异步编程之美!
CompletableFuture-常用API
xiatianyangwang的博客
09-05 433
【代码】CompletableFuture练习。
【Java高级】通过CompletableFuture类异步、并行获取数据库数据
jayxiaoxionger的博客
02-02 1018
通过CompletableFuture类并行执行多个任务、等待多个任务完成
Java8 异步非阻塞做法：CompletableFuture 两万字详解！
weixin_44421461的博客
12-11 784
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 Elast...
java8 Stream流多线程
qq_50523945的博客
01-25 1004
在对集合遍历的时候可以使用Stream，如果想要继续提高执行效率可以使用parallelStream()并行流。使用parallelStream()的主要优点是可以极大地提高程序的性能。在处理大量数据时，可以将数据分成多个部分，并在不同的处理器核心上并行处理每个部分。避坑：在流中不要使用sorted()、distinct()操作，应该尽量避免在流操作中修改流源。如果必须修改流源，可以考虑使用线程安全的数据结构来避免竞争条件。parallelStream()，流的外面就需要使用线程安全的集合了。
在netty中使用CompletableFuture配合ScheduledExecutorService实现服务端主动给客户端发消息
weixin_57730366的博客
06-09 1586
Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序,是目前最流行的 NIO 框架，Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。
java异步调用CompletableFuture的使用
09-01
Java异步调用CompletableFuture是一种非常强大的工具，它可以帮助我们处理异步编程的复杂性。下面是一个简单的示例，展示了CompletableFuture的基本用法： ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CompletableFutureExample { public static void main(String[] args) { // 创建一个线程池 ExecutorService executor = Executors.newFixedThreadPool(3); // 异步执行任务 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return "Hello, World!"; }, executor); // 注册回调函数 future.thenAccept(result -> System.out.println("Result: " + result)); // 关闭线程池 executor.shutdown(); } } ``` 在上面的例子中，我们首先创建了一个线程池，然后使用`CompletableFuture.supplyAsync()`方法将任务异步执行。在这个示例中，任务会休眠1秒钟，然后返回一个字符串结果"Hello, World!"。 接下来，我们通过调用`thenAccept()`方法注册了一个回调函数，该函数会在任务完成后被调用，并且会打印出结果。 最后，我们关闭了线程池。 需要注意的是，CompletableFuture还提供了很多其他的方法，可以帮助我们实现更加复杂的异步编程逻辑，比如`thenApply()`、`thenCompose()`、`thenCombine()`等等。你可以根据具体的需求选择适合的方法来使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值