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

曹举的个人博客

已于 2022-01-19 14:46:10 修改

阅读量3.7k

点赞数 4

CC 4.0 BY-SA版权

分类专栏：工具使用 Java开发总结文章标签： java

于 2021-05-28 14:51:20 首次发布

本文链接：https://blog.youkuaiyun.com/ju_362204801/article/details/117325220

Java开发总结同时被 2 个专栏收录

134 篇文章

订阅专栏

工具使用

61 篇文章

订阅专栏

本文详细介绍了Java中CompletableFuture的使用，包括单任务、两任务、三任务和多任务的异步编排，以及在实际场景中的应用示例，展示了如何通过CompletableFuture实现线程间的依赖执行和结果处理，提升并发性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

为什么需要CompletableFuture？

当多线程任务出现了相互依赖，需要按照一定的顺序执行的时候，

比如：当线程1执行完后，线程2才能执行或线程2的运行需要使用到线程1的执行结果

类似这种或者更复杂的情况，就需要用到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：有返回值

+whenComplete：能感知异常，能感知结果，但没办法给返回值
+exceptionally：能感知异常，不能感知结果，能给返回值。相当于，如果出现异常就返回这个值

/**
 * 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();

五、一个实际的例子

使用CompletableFuture异步编排之前

public SkuItemVo item(Long skuId) {
        SkuItemVo skuItemVo = new SkuItemVo();

        //1、sku详细信息 sku_info
        SkuInfoEntity skuInfo = getById(skuId);
        skuItemVo.setInfo(skuInfo);

        //2、sku 图片信息 sku_img
        List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
        skuItemVo.setImages(images);

        //3、spu 销售属性组合
        List<SkuItemSaleAttrVo> saleAttr = skuSaleAttrValueService.getSaleAttrBySpuId(skuInfo.getSpuId());
        skuItemVo.setSaleAttr(saleAttr);

        //4、spu 的介绍
        SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(skuInfo.getSpuId());
        skuItemVo.setDesc(spuInfoDesc);

        //5、spu 规格参数信息
        List<SpuItemAttrGroupVo> groupAttrs = attrGroupService.getAttrGroupWithAttrsBySpuId(skuInfo.getSpuId(),skuInfo.getCatalogId());
        skuItemVo.setGroupAttrs(groupAttrs);

        return skuItemVo;
    }

使用CompletableFuture异步编排后

private SkuItemVo item(Long skuId) {
	SkuItemVo skuItemVo = new SkuItemVo();

	/**
	 * 3、4、5需要依赖1的运行结果，需要返回skuInfo后从中获取spuId和catalogId
	 * 而2不需要依赖1的运行结果
	 */

	//1、sku详细信息 sku_info
	CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> {
		SkuInfoEntity skuInfo = getById(skuId);
		skuItemVo.setInfo(skuInfo);
		return skuInfo;
	}, executor);

	//2、sku 图片信息 sku_img  2不需要等待上边1的执行结果
	CompletableFuture<Void> imageFuture = CompletableFuture.runAsync(() -> {
		List<SkuImagesEntity> images = skuImagesService.getImagesBySkuId(skuId);
		skuItemVo.setImages(images);
	}, executor);

	//下边的3、4、5都需要上边1的执行结果
	//所以下边的3、4、5都是基于上边1的执行结果 infoFuture 开始的
	//都是以infoFuture.thenAcceptAsync(skuInfo -> {})开始的
	CompletableFuture<Void> saleAttrFuture = infoFuture.thenAcceptAsync(skuInfo -> {
		//3、spu 销售属性组合  3
		List<SkuItemSaleAttrVo> saleAttr = skuSaleAttrValueService.getSaleAttrBySpuId(skuInfo.getSpuId());
		skuItemVo.setSaleAttr(saleAttr);
		System.out.println(saleAttr);
	}, executor);

	CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync(skuInfo -> {
		//4、spu 的介绍
		SpuInfoDescEntity spuInfoDesc = spuInfoDescService.getById(skuInfo.getSpuId());
		skuItemVo.setDesc(spuInfoDesc);
	}, executor);

	CompletableFuture<Void> attrGroupFuture = infoFuture.thenAcceptAsync(skuInfo -> {
		//5、spu 规格参数信息
		List<SpuItemAttrGroupVo> groupAttrs = attrGroupService.getAttrGroupWithAttrsBySpuId(skuInfo.getSpuId(),skuInfo.getCatalogId());
		System.out.println(groupAttrs);
		skuItemVo.setGroupAttrs(groupAttrs);
	}, executor);

	

	//等待所有任务完成
	try {
		CompletableFuture.allOf(saleAttrFuture,descFuture,attrGroupFuture,imageFuture).get() ;
	} catch (InterruptedException e) {
		log.error("查询商品详情异步编排错误: ");
		log.error(e.getMessage() );
	} catch (ExecutionException e) {
		log.error(e.getMessage() );
	}
	return skuItemVo;
}

纯手敲原创不易，如果觉得对你有帮助，可以打赏支持一下，哈哈，感谢~