禅与计算机
sharkchili
2023-07-11
目录

CompletableFuture组合流水线任务实践

# 写在文章开头

CompletableFuture支持将异步任务组合执行，对于流水线的IO型任务效率有质的提升，所以笔者本文就以一个电商的例子演示一下CompletableFuture如何高效处理流水线的任务。

你好，我叫sharkchili，目前还是在一线奋斗的Java开发，经历过很多有意思的项目，也写过很多有意思的文章，是CSDN Java领域的博客专家，也是Java Guide的维护者之一，非常欢迎你关注我的公众号：写代码的SharkChili，这里面会有笔者精心挑选的并发、JVM、MySQL数据库专栏，也有笔者日常分享的硬核技术小文。

# 提出一个需求

本文所有案例都会基于这样的一个需求，用户会在不同的店铺查看同一件商品，只要用户在提供给商店对应的产品名称，商店就会返回对应产品的价格和折扣、以及最终折后价。 该需求有几个注意点:

  1. 每次到一家商店查询时，同一时间只能查询一个商品。
  2. 允许用户同一时间在系统里查询多个商店的一个商品。
  3. 查询的商品售价是需要耗时的，平均500ms-2500ms不等。
  4. 为了更直观了解代码性能，我们的例子用户每次会去10家左右的店铺分别查询一件商品。

介绍完需求之后，我们再把后续案例中要用到类全部标注出来，首先是商店类,代码比较简单，核心方法就是calculatePrice只要我们传入一个商品名返回:商品名:价格:折扣代码，需要注意的是这里为了模拟远程调用等待，笔者在方法里使用TimeUnit随机休眠500-2500ms不等。

/**
 * 商店
 */
public class Shop {

    private final String name;
    private final Random random;

    public Shop(String name) {
        this.name = name;
        random = new Random(name.charAt(0) * name.charAt(1) * name.charAt(2));
    }

    /**
     * 传入产品名称返回对应价格和折扣代码
     * @param product 产品名称
     * @return
     */
    public String getPrice(String product) {
        double price = calculatePrice(product);
        Discount.Code code = Discount.Code.values()[random.nextInt(Discount.Code.values().length)];
        return name + ":" + price + ":" + code;
    }

    /**
     * 获取商品价格
     * @param product
     * @return
     */
    public double calculatePrice(String product) {
        try {
            TimeUnit.MILLISECONDS.sleep(RandomUtil.randomInt(500,2500));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return (int)(random.nextDouble() * product.charAt(0) + product.charAt(1));
    }

    public String getName() {
        return name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

然后就是商品信息类，核心方法即parse，我们上文中calculatePrice会返回商品名:价格:折扣代码，parse就是将这个字符串转为描述商品信息的对象Quote。

/**
 * 商品信息
 */
public class Quote {

    /**
     * 商品名称
     */
    private final String shopName;
    /**
     * 商品价格
     */
    private final double price;
    /**
     * 折扣代码
     */
    private final Discount.Code discountCode;

    public Quote(String shopName, double price, Discount.Code discountCode) {
        this.shopName = shopName;
        this.price = price;
        this.discountCode = discountCode;
    }

    /**
     * 将传入的字符串转为商品信息类
     * @param s
     * @return
     */
    public static Quote parse(String s) {
        String[] split = s.split(":");
        String shopName = split[0];
        double price = Double.parseDouble(split[1]);
        Discount.Code discountCode = Discount.Code.valueOf(split[2]);
        return new Quote(shopName, price, discountCode);
    }

    public String getShopName() {
        return shopName;
    }

    public double getPrice() {
        return price;
    }

    public Discount.Code getDiscountCode() {
        return discountCode;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

接下来就是折扣类了，内部声明了折扣枚举和返回折后价的方法applyDiscount，注意applyDiscount中的apply是计算折扣价的核心方法，为了模拟远程调用笔者也设置了随机休眠。

/**
 * 折扣
 */
public class Discount {

    public enum Code {
        NONE(0), //不打折
        SILVER(5), //打九五折
        GOLD(10), //打九折
        PLATINUM(15), //打八五折
        DIAMOND(20);//打八折

        private final int percentage;

        Code(int percentage) {
            this.percentage = percentage;
        }
    }

    /**
     * 传入产品类 返回折扣后的价格
     * @param quote
     * @return
     */
    public static String applyDiscount(Quote quote) {
        return quote.getShopName() + " price is " +
                Discount.apply(quote.getPrice(), quote.getDiscountCode());
    }
    private static int apply(double price, Code code) {
        //模拟远程调用耗时
        try {
            TimeUnit.MILLISECONDS.sleep(RandomUtil.randomInt(500,2500));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return (int)(price * (100 - code.percentage) / 100) ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

最后我们用一个列表随机存储生成七家商铺，自此我们所有的准备工作都完成了，接下来我们就会通过不断的演进实现CompletableFuture组合流水线任务提升代码执行效率。

 private final static List<Shop> shops = Arrays.asList(new Shop("Nike"),
            new Shop("Adidas"),
            new Shop("MyFavoriteShop"),
            new Shop("BuyItAll"),
            new Shop("ShopEasy"),
            new Shop("BestPrice"),
            new Shop("LetsSaveBig")
    );
1
2
3
4
5
6
7
8

# 付出实践

# 使用常规流式编程

我们首先用jdk8的顺序流完成这个需求，流的执行步骤也很清晰:

  1. 遍历每一家商店。
  2. 查询商品信息(存在500-2500ms耗时)。
  3. 生成商品信息。
  4. 根据原价、折扣获取最终价格。
  5. 生成列表。
 public static void main(String[] args) {
        String product = "AJ basketball shoes";

        long begin = System.currentTimeMillis();

        List<String> productList = shops.stream()
                .map(shop -> shop.getPrice(product))//到每一个商店获取价格，返回商品名:价格:折扣代码 给下一个流，该方法有随机耗时
                .map(Quote::parse)//生成商品信息对象
                .map(Discount::applyDiscount)//计算折扣，该方法会有随机耗时
                .collect(Collectors.toList());

        System.out.println(JSONUtil.toJsonStr(productList));
        System.out.println("查询结束，总耗时:" + (System.currentTimeMillis() - begin) + "ms");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

从输出结果可以看出，本次执行耗时差不多21s，效率非常差。

["Nike price is 72","Adidas price is 86","MyFavoriteShop price is 116","BuyItAll price is 112","ShopEasy price is 100","BestPrice price is 67","LetsSaveBig price is 81"]
查询结束，总耗时:21040ms
1
2

原因很简单，顺序流每一个阶段的流操作必须等上一个流中所有的元素都完成了才能继续向下走。

这一点我们可以用peek表达式印证:

public static void main(String[] args) {
        String product = "AJ basketball shoes";

        long begin = System.currentTimeMillis();

        List<String> productList = shops.stream()
                .map(shop -> shop.getPrice(product))//到每一个商店获取价格，返回商品名:价格:折扣代码 给下一个流，该方法有随机耗时
                .peek(s-> System.out.println(s))
                .map(Quote::parse)//生成商品信息对象
                .map(Discount::applyDiscount)//计算折扣，该方法会有随机耗时
                .peek(j-> System.out.println(j))
                .collect(Collectors.toList());

        System.out.println(JSONUtil.toJsonStr(productList));
        System.out.println("查询结束，总耗时:" + (System.currentTimeMillis() - begin) + "ms");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

从输出结果可以看出，只有所有商店的getPrice执行完成后流才继续向下执行applyDiscount。

Nike:81.0:GOLD
Nike price is 72
Adidas:102.0:PLATINUM
Adidas price is 86
MyFavoriteShop:129.0:GOLD
MyFavoriteShop price is 116
BuyItAll:112.0:NONE
BuyItAll price is 112
ShopEasy:106.0:SILVER
ShopEasy price is 100
BestPrice:75.0:GOLD
BestPrice price is 67
LetsSaveBig:102.0:DIAMOND
LetsSaveBig price is 81
["Nike price is 72","Adidas price is 86","MyFavoriteShop price is 116","BuyItAll price is 112","ShopEasy price is 100","BestPrice price is 67","LetsSaveBig price is 81"]
查询结束，总耗时:20132ms
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 使用并行流

对此我们可以用并行流实现每一个阶段的流操作并行执行，所以我们将stream改为parallelStream。

public static void main(String[] args) {
        String product = "AJ basketball shoes";

        long begin = System.currentTimeMillis();

        List<String> productList = shops.parallelStream()
                .map(shop -> shop.getPrice(product))//到每一个商店获取价格，返回商品名:价格:折扣代码 给下一个流，该方法有随机耗时
                .map(Quote::parse)//生成商品信息对象
                .map(Discount::applyDiscount)//计算折扣，该方法会有随机耗时
                .collect(Collectors.toList());

        System.out.println(JSONUtil.toJsonStr(productList));
        System.out.println("查询结束，总耗时:" + (System.currentTimeMillis() - begin) + "ms");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

从输出结果来看，并行流耗时只需5s多，效率相比顺序高提升不少。

["Nike price is 72","Adidas price is 86","MyFavoriteShop price is 116","BuyItAll price is 112","ShopEasy price is 100","BestPrice price is 67","LetsSaveBig price is 81"]
查询结束，总耗时:5194ms
1
2

# 使用CompletableFuture组合流程

这一步我们采用CompletableFuture的组合方式，将获取售价、生成商品信息、计算最终折扣价以流的方式封装成CompletableFuture的列表，再通过join阻塞顺序获取列表中各个任务的结果。

代码如下，可以看到笔者的实现思路就两大步:

  1. 将获取售价、生成商品信息、计算折扣封装成CompletableFuture。
  2. 顺序遍历调用join阻塞获取每个已经提交并且在执行的CompletableFuture任务的结果。
 public static void main(String[] args) {
        String product = "AJ basketball shoes";

        long begin = System.currentTimeMillis();

        List<String> productList = shops.stream()
                .map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product), executor))//到每一个商店获取价格，返回商品名:价格:折扣代码 给下一个流，该方法有随机耗时
                .map(future -> future.thenApply(Quote::parse))//上一个异步任务完成后再异步生成商品信息对象
                .map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor)))//上一个任务完成后生成一// 个计算折扣价的异步任务对象 CompletableFuture
                .collect(Collectors.toList())//生成异步任务的列表
                .stream()
                .map(CompletableFuture::join)//阻塞获取每一个任务的结果
                .collect(Collectors.toList());//生成list
        ;


        System.out.println(JSONUtil.toJsonStr(productList));
        System.out.println("查询结束，总耗时:" + (System.currentTimeMillis() - begin) + "ms");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果如下，可以看到时间为4s多，因为自定义线程池的原因，相比并行流会快一些。

查询结束，总耗时:4713ms
1

如果想了解流的执行流程，我们建议使用peek在每一个操作上打一个输出，如下所示:

public static void main(String[] args) {
        String product = "AJ basketball shoes";

        long begin = System.currentTimeMillis();

        List<String> productList = shops.stream()
                .map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product), executor))//到每一个商店获取价格，返回商品名:价格:折扣代码 给下一个流，该方法有随机耗时
                .peek(s-> System.out.println("supplyAsync"))
                .map(future -> future.thenApply(Quote::parse))//上一个异步任务完成后再异步生成商品信息对象
                .peek(s-> System.out.println("thenApply"))
                .map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor)))//上一个任务完成后生成一// 个计算折扣价的异步任务对象 CompletableFuture
                .peek(s-> System.out.println("thenCompose"))
                .collect(Collectors.toList())//生成异步任务的列表
                .stream()
                .peek(s-> System.out.println("join"))
                .map(CompletableFuture::join)//阻塞获取每一个任务的结果
                .peek(s-> System.out.println("result: "+s))
                .collect(Collectors.toList());//生成list
        ;


        System.out.println(JSONUtil.toJsonStr(productList));
        System.out.println("查询结束，总耗时:" + (System.currentTimeMillis() - begin) + "ms");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出结果如下,从结果来看和笔者上文绘制的图片是一致的，先封装成CompletableFuture任务，然后顺序调用join获取结果。

supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
supplyAsync
thenApply
thenCompose
join
result: Nike price is 72
join
result: Adidas price is 86
join
result: MyFavoriteShop price is 116
join
result: BuyItAll price is 112
join
result: ShopEasy price is 100
join
result: BestPrice price is 67
join
result: LetsSaveBig price is 81
["Nike price is 72","Adidas price is 86","MyFavoriteShop price is 116","BuyItAll price is 112","ShopEasy price is 100","BestPrice price is 67","LetsSaveBig price is 81"]
查询结束，总耗时:4713ms
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# 拓展需求(汇率转换)

# 需求描述

我们上文计算的价格是欧元，我们希望将其转换为美元给用户展示。同样的，汇率转换也需要远程调用，同样是耗时的操作，所以对于这需求的实现我们还是要考虑性能问题。

这里我们也给出的获取汇率的工具类，通过调用getRate传入源币种和转换币种即可获取到汇率。

public class ExchangeService {
    public enum Money {
        USD(1.0), 
        EUR(1.35387),
        GBP(1.69715),
        CAD(.92106),
        MXN(.07683);

        private final double rate;

        Money(double rate) {
            this.rate = rate;
        }
    }

    public static double getRate(Money source, Money destination) {
        return getRateWithDelay(source, destination);
    }

    private static double getRateWithDelay(Money source, Money destination) {
        try {
            TimeUnit.MILLISECONDS.sleep(RandomUtil.randomInt(500,2500));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return destination.rate / source.rate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

以及为了更好的演示

# 使用组合关系解决问题

最终我们的代码改造成这样，改造也很简单，将转换quote的异步任何用thenCombine和获取汇率的异步任何组合起来，用各自的结果封装成一个函数(quote, rate) -> quote.getShopName() + ":" + quote.getPrice() * rate)得到最终的CompletableFuture。 最后再用流式编程遍历每个CompletableFuture并调用join阻塞获取结果。

public static List<String> findPricesInUSD(String product) {
        List<CompletableFuture<String>> priceFutureList = shops.stream()
                .map(s -> CompletableFuture.supplyAsync(() -> s.getPrice(product), executor))//获取商品售价，该方法可能会阻塞所以这一步将操作封装成CompletableFuture
                .map(f -> f.thenApply(Quote::parse))//基于上一步CompletableFuture完成后，顺序执行thenApply转换成商品信息
                .map(f -> f.thenCombine(CompletableFuture.supplyAsync(() -> ExchangeService.getRate(ExchangeService.Money.EUR, ExchangeService.Money.USD), executor), (quote, rate) -> quote.getShopName() + ":" + quote.getPrice() * rate))//重点，将上一步的CompletableFuture得到的quote和ExchangeService.getRate的异步任务得到的rate得到最终的结果字符串
                .collect(Collectors.toList());//组装成list


        List<String> prices = priceFutureList
                .stream()
                .map(CompletableFuture::join)//join阻塞获取各个流的结果
                .map(Function.identity())
                .collect(Collectors.toList());


        return prices;
    }


    public static void main(String[] args) {
        List<String> resultList = findPricesInUSD("AJ basketball shoes");
        System.out.println(JSONUtil.toJsonStr(resultList));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

最终输出结果如下:

["Nike:59.828491657249224","Adidas:75.33958208690643","MyFavoriteShop:95.28241263932284","BuyItAll:82.72581562483843","ShopEasy:78.29407550207924","BestPrice:55.39675153449002","LetsSaveBig:75.33958208690643"]
1
2

# 小结

我是sharkchili，CSDN Java 领域博客专家，开源项目—JavaGuide contributor，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili，同时我的公众号也有我精心整理的并发编程、JVM、MySQL数据库个人专栏导航。

# 参考文献

Java 8实战:https://book.douban.com/subject/26772632/ (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
CompletableFuture异步多任务最佳实践
实现一个简单实用的的并发同步模型

← 实现一个简单实用的的并发同步模型→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×