Java中CompletableFuture多线程任务异步编排-java黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

以天使的名义

605

文章

291518

访问

+关注

分类

暂无分类

日期归档

暂无数据

Java中CompletableFuture多线程任务异步编排

发布于2021-05-29 22:39 阅读(615) 评论(0) 点赞(24) 收藏(0)

今天来简单看一下CompletableFuture多线程任务异步编排

为什么需要CompletableFuture？

当多线程任务出现了相互依赖，需要按照一定的顺序执行的时候就需要用到CompletableFuture多线程任务异步编排

按照我的理解：CompletableFuture可以分为一下几种情况

1、单个任务

2、两任务的编排

3、三任务的编排

4、多任务的编排

一、单个任务

1、runAsync无返回值


/**
 * runAsync无返回值
 */
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
}, executor);

2、supplyAsync有返回值


/**
 * supplyAsync有返回值
 * whenComplete能感知异常，能感知结果，但没办法给返回值
 * exceptionally能感知异常，不能感知结果，能给返回值。相当于，如果出现异常就返回这个值
 */
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).whenComplete((res,excption)->{
    //whenComplete虽然能得到异常信息，但是没办法修改返回值
    System.out.println("异步任务成功完成...结果是："+res+";异常是："+excption);
}).exceptionally(throwable -> {
    //exceptionally能感知异常，而且能返回一个默认值，相当于，如果出现异常就返回这个值
    return 10;
});

3、supplyAsync有返回值+handle


/**
* supplyAsync有返回值
* handle能拿到返回结果，也能得到异常信息，也能修改返回值
*/
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程" + Thread.currentThread().getId());
    int i = 10 / 4;
    System.out.println("运行结果：" + i);
    return i;
}, executor).handle((res,excption)->{
    if(excption!=null){
        return 0;
    }else {
        return res * 2;
    }
});

二、两任务的编排

两任务组合（线程串行化）
可以是两任务的串行化，就是一个任务执行完了再执行下一个
也可以是多个任务的串行化，就是按照顺序一个个的执行

1、thenRunAsync


        /**
         * thenRunXXX 不能接收上一次的执行结果，也没返回值
         * .thenRunAsync(() -> {
         *      System.out.println("任务2启动了...");
         * }, executor);
         */
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenRunAsync(() -> {
            System.out.println("任务2启动了...");
        }, executor);

2、thenAcceptAsync


        /**
         * thenAcceptXXX 能接收上一次的执行结果，但没返回值
         * .thenAcceptAsync(res->{
         *      System.out.println("任务2启动了..."+res);
         *  },executor);
         */
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenAcceptAsync(res -> {
            System.out.println("任务2启动了..." + res);
        }, executor);

3、thenApplyAsync


        /**
         * thenApplyXXX 能接收上一次的执行结果，又可以有返回值
         * .thenApplyAsync(res -> {
         *      System.out.println("任务2启动了..." + res);
         *      return "hello " + res;
         *  }, executor);
         */
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了..." + res);
            return "hello " + res;
        }, executor);

三、三任务的编排

先准备两个任务


 
        CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("任务1结束：");
            return i;
        }, executor);
        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
                System.out.println("任务2结束：");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, executor);

1、三任务组合，前两个任务都完成，才执行任务3

1.1、runAfterBothAsync

任务01 任务02都完成了，再开始执行任务3，不感知任务1、2的结果的，也没返回值


        CompletableFuture<Void> future = future01.runAfterBothAsync(future02, () -> {
            System.out.println("任务3开始");
        }, executor);

1.2、thenAcceptBothAsync
任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，但没返回值


        CompletableFuture<Void> future = future01.thenAcceptBothAsync(future02, (f1, f2) -> {
            System.out.println("任务3开始...得到之前的结果：f1:" + f1 + ", f2:" + f2);
        }, executor);

1.3、 thenCombineAsync

任务01 任务02都完成了，再开始执行任务3，能感知到任务1、2的结果，而且自己可以带返回值


        CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1+":"+f2+"：哈哈";
        }, executor);

2、三任务组合，前两个任务只要有一个完成，就执行任务3

2.1、runAfterEitherAsync

两个任务只要有一个完成，就执行任务3，不感知结果，自己没返回值


        CompletableFuture<Void> future = future01.runAfterEitherAsync(future02, () -> {
            System.out.println("任务3开始...");
        }, executor);

2.2、acceptEitherAsync

两个任务只要有一个完成，就执行任务3，感知结果，自己没返回值


        CompletableFuture<Void> future = future01.acceptEitherAsync(future02, (res) -> {
            System.out.println("任务3开始...之前的结果" + res);
        }, executor);

2.3、applyToEitherAsync

两个任务只要有一个完成，就执行任务3，感知结果，自己有返回值


        CompletableFuture<String> future = future01.applyToEitherAsync(future02, (res) -> {
            System.out.println("任务3开始...之前的结果" + res);
            return "任务3的结果...";
        }, executor);

四、多任务的编排


        /**
         * 多任务组合
         */
        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品图片信息");
            return "hello.jpg";
        },executor);
 
        CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品属性信息");
            return "黑色+256G";
        },executor);
 
        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品介绍信息");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "华为...";
        },executor);

1、allOf 所有任务都执行完


        /**
         * allOf 所有任务都执行完
         */
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
        allOf.get();//等待所有结果完成

2、anyOf 其中有一个任务执行完就可以


        /**
         * anyOf 其中有一个任务执行完就可以
         */
        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(futureImg, futureAttr, futureDesc);
        anyOf.get();