CompleteFuture实现简单的任务编排实践

CompleteFuture实现简单的任务编排实践

一:前言

​ CompleteFuture是java8 新提供的API,是对函数式编程思想的体现,提供了很多的对于函数式编程支持。不止有同步处理功能,还有异步处理能力。

通过函数式编程可以实现线程的简单任务编排。高效,整洁实现多线程异步编程。

二:详细介绍

CompleteFuture 提供的API中以ansy结尾的都是异步处理的。

  1. 异步执行任务,并返回结果:supplyAsync 异步处理,并返回结果,默认使用 ForkJoinPool.commonPool()线程池,同时提供支持自定义线程池的API。

    CompletableFuture.supplyAsync(() -> "HELLO");
    // 自定义线程池
    CompletableFuture.supplyAsync(()->"hello",ES);
    
    1. 异步执行任务,不返回结果:runAsync
    CompletableFuture.runAsync(() -> System.out.println("HELLO WORLD !"));
    CompletableFuture.runAsync(() -> System.out.println("HELLO WORLD !"),ES);
    
    1. 依赖单一阶段:thenApply thenApplyAsync
        CompletableFuture future = CompletableFuture.supplyAsync(() -> "HELLO")
                    .thenApply(a -> 
                        return a + " lili!";
                    });
    
    1. 组合与撰写:thenCompose()thenCombine()thenCombineAsync.
       CompletableFuture f1 =
                    CompletableFuture.supplyAsync(() -> "hello")
                            .thenCompose(res -> CompletableFuture.supplyAsync(() -> res + " lili"))
                            .thenCompose(res -> CompletableFuture.supplyAsync(() -> res + " lucy"));
    // 执行结果: =====> hello lili lucy
    // mian线程下同步执行。
    
      CompletableFuture f1 =
                    CompletableFuture.supplyAsync(() -> "hello")
                            .thenCompose(res -> CompletableFuture.supplyAsync(() -> res + " lili"))
                            .thenCompose(res -> CompletableFuture.supplyAsync(() -> res + " lucy"))
                            .thenCombineAsync(CompletableFuture.supplyAsync(() -> " how are you!"), (a, b) -> a + b);
            log.info("=====> {}", f1.get());
      // 执行结果: =====> hello lili lucy how are you!
    
    1. 依赖两个任务中的一个:applyToEither() ,那个任务先结束,就依赖那个任务。
            CompletableFuture voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
                try {TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace();}
                return "lucy";
            }).applyToEither(CompletableFuture.supplyAsync(() -> {
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
                return "lili";
            }), a -> "hello " + a);
            log.info("ret ====> {}",voidCompletableFuture.get());
    // 执行结果: ret ====> hello lili 如果下面sleep改成3s,执行结果:ret ====> hello lucy
    
    1. 消费型,依赖单阶段: thenAccept()thenAcceptAsync()
            CompletableFuture future = CompletableFuture.supplyAsync(() -> "hello")
                    .thenAcceptAsync(a -> {
                        a = a + " lucy !";
                        log.info("ret ======> {}", a);
                    });
             log.info(" ======== end ========================");
    // 执行结果:ret ======> hello lucy ! 而且是异步的,不会阻塞主线程,下面的end是先打印出来的
    
    1. 消费型,依赖两个任务都完成:thenAcceptBoth()thenAcceptBothAsync()
         CompletableFuture.supplyAsync(() -> "hello")
                    .thenAcceptBoth(CompletableFuture.supplyAsync(() -> " lili"), (a, b) -> {
                        try {
                            TimeUnit.SECONDS.sleep(3);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        log.info("=======>{}", a + b);
                    });
    // 执行结果:=======>hello lili 
    
    1. 消费型:acceptEither() 依赖两个任务中先执行结束的那个
        CompletableFuture.supplyAsync(() -> {
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "lucy";
            }).acceptEither(CompletableFuture.supplyAsync(() -> "lili"), a -> {
                log.info("hello {}", a);
            });
            
     // 执行结果:hello lili
    
    1. 消费型,无论正常,还是异常都会消费处理,而且不会吞掉异常 whenComplete()whenCompleteAsync()
          CompletableFuture future = CompletableFuture.supplyAsync(() -> {
                if (ThreadLocalRandom.current().nextInt(2) < 2) {
                    throw new RuntimeException("error");
                }
                return "hello";
            }).whenComplete((a, e) -> {
               log.info("ret -> {}", a + " lili!");
               log.error("error", e);
            });
            log.info("future.get()-->{}", future.get());
            
     // 执行结果:ret -> null lili!  而且打印两次错误日志,一次是log打印,一次是get的时候。
    
    1. 产出型,无论正常还是异常都是处理,并返回结果。handlehandleAsync
      CompletableFuture future = CompletableFuture.supplyAsync(() -> "hello")
                    .handle((a, e) -> a + " lili!");
    
            log.info("ret ==> {}", future.get());
    
    // 执行结果:ret ==> hello lili!
    
    1. 产出型,异常时候进行处理,并产出,有点像try-catch(),exceptionally()
       CompletableFuture f =
                    CompletableFuture.supplyAsync(() -> "Hello")
                            .thenApplyAsync(res -> res + " World")
                            .thenApplyAsync(
                                    res -> {
                                        throw new RuntimeException(" test has error");
                                        //  return res + "!";
                                    })
                            .exceptionally(
                                    e -> {
                                        log.error("exceptionally exception",e);
                                        return "出异常了。。";
                                    });
     log.info("ret ====> {}", f.get());
    
    // 执行结果:ret ====> 出异常了。。
    // 假如不抛出异常,执行结果:ret ====> Hello World!
    
    
    1. 无关性任务,互相依赖,allOf
         CompletableFuture f3 = CompletableFuture.supplyAsync(() -> "hello");
            CompletableFuture f4 = CompletableFuture.supplyAsync(() -> "world");
            CompletableFuture f5 =
                    CompletableFuture.supplyAsync(
                            () -> {
                                try {
                                    TimeUnit.SECONDS.sleep(3);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                return "!";
                            });
    
            // 使用allOf方法 f3 f4 f5 都执行结束之前一直阻塞
            CompletableFuture.allOf(f3, f4, f5).join();
    
            System.out.println(f3.get());
            System.out.println(f4.get());
            System.out.println(f5.get());
            List r =
                    Stream.of(f3, f4, f5).map(CompletableFuture::join).collect(Collectors.toList());
    
            System.out.println(r);
            
            
    // 执行结果:hello
    // world
    // !
    // [hello, world, !]
    // 而且要等f1,f2,f3 三个任务都结束,不然会一直阻塞。
    

    这个类中的大部分方法上面都做了介绍,下面可以结合具体场景做一次演示。

    三:DEMO

    ​ 场景1:需要查询一个订单信息,首先需要查询商品信息,然后查询支付信息,最后汇总成一个对象返回。

         CompletableFuture future = CompletableFuture.supplyAsync(() -> "商品信息")
                    .thenCombineAsync(CompletableFuture.supplyAsync(() -> "支付信息"), (a, b) -> {
                        // 组装信息
                        return a + b;
                    });
            log.info("ret =========>{}",future.get());
    

    ​ 场景2:用户注册,首先需要校验用户信息,然后生成账号信息,最后保存到数据库。这三个操作互相依赖。

     // A -> B-> C
            CompletableFuture future = CompletableFuture.runAsync(() -> {
                if (ThreadLocalRandom.current().nextBoolean()){
                    return;
                }
                throw new RuntimeException("该手机号码已经注册");
            }).thenCompose(ret -> CompletableFuture.supplyAsync(() -> {
                        if (ThreadLocalRandom.current().nextBoolean()) {
                            // 生成账号信息
                            return "账号信息: 16289";
                        }
                        throw new RuntimeException("账号信息生成失败。。");
                    })).thenApplyAsync(ret -> {
                        // 保存账号信息
                        log.info("保存账号信息->{}", ret);
                        return "注册成功";
                    }).exceptionally(e -> "注册失败" + e.getMessage());
    
            log.info("最终返回结果:===》 {}",future.get());
    
    原文链接:,转发请注明来源!