使用CompletableFuture构建异步应用 （2）

最新推荐文章于 2024-08-22 09:42:02 发布
最新推荐文章于 2024-08-22 09:42:02 发布
阅读量243 收藏 2
点赞数 1
分类专栏： Java 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duke_ding2/article/details/106751628
版权

（接上文）

现在，我们假设每张饼都需要烙正、反两面，每一面烙熟需要1秒钟：

package package0614;

import java.util.Random;

public class Dabing2 {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Dabing2(String name) {
		this.name = name;
	}

	public double laoZheng() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
		return this;
	}

	public double laoFan() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
		return new Random().nextDouble() * 100;
	}
}

第1次尝试，使用stream烙5张饼：

	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
                                new Dabing2("B"),
                                new Dabing2("C"),
                                new Dabing2("D"),
                                new Dabing2("E"));
		List<String> results = list.stream().map(e -> e.laoZheng()).map(e -> e.getName() + ": " + e.laoFan())
				.collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 55.4523443439747, B: 49.47515167835467, C: 63.02314261631643, D: 3.789149628644528, E: 73.51160030525537]

Total time: 10086ms

不出所料，需要10秒钟时间。

第2次尝试，使用parallelStream烙5张饼：

	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
                                new Dabing2("B"),
                                new Dabing2("C"),
                                new Dabing2("D"),
                                new Dabing2("E"));
		List<String> results = list.parallelStream().map(e -> e.laoZheng()).map(e -> e.getName() + ": " + e.laoFan())
				.collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 37.39151716337421, B: 15.775742198107622, C: 31.667344024582167, D: 14.386117456032943, E: 5.913311718908054]

Total time: 2060ms

不出所料，需要2秒钟时间。

第3次尝试：使用CompletableFuture：

	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"));
		List<CompletableFuture<String>> listFuture = new ArrayList<>();

		for (Dabing2 dabing2 : list) {
			CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> dabing2.laoZheng())
					.thenApply(e -> e.getName() + ": " + e.laoFan());
			listFuture.add(future);
		}
		List<String> results = listFuture.stream().map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 91.15306335229461, B: 24.368638002069932, C: 61.34350781335267, D: 36.89446490304583, E: 51.432231549457605]

Total time: 2054ms

不出所料，需要2秒钟时间。

第4次尝试：如果换成10张饼呢？代码略，运行结果如下：

[A: 96.13014798074259, B: 69.23653704155743, C: 62.89131092514255, D: 57.929321535499376, E: 72.87524123696774, F: 71.44149392741076, G: 57.32601348732903, H: 83.38410150602131, I: 94.85882057820052, J: 50.351187872048044]

Total time: 4066ms

为什么需要4秒钟，而不是3秒钟呢？原因在于，thenApply()方法的操作，是和之前的Future在同一个线程里面串行工作的。这也就是文章最开头提到的第1种方法。

我们可以把CPU想象成坑，线程就是小碗，饼是放在小碗里，然后放在锅上烙。烙完A的正面，接着烙A的反面。烙完B的正面，接着烙B的反面。导致C一直在等待。而等到C开始工作，已经有小碗和坑空闲了，但是C的正反面只能串行烙，所以一共需要4秒钟。

有的同学说了，这是因为没有配置Executor的并发线程数，默认值是8个线程，所以花了4秒钟，如果配置100个线程，那么10个任务线程就可以并发运行了。这种说法也是正确的。请思考一下一共需要花多长时间？代码如下：

第5次尝试：使用100个并发线程烙10张饼：

    private static final Executor executor = Executors.newFixedThreadPool(100, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
    });
	
	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"),
								new Dabing2("F"),
								new Dabing2("G"),
								new Dabing2("H"),
								new Dabing2("I"),
								new Dabing2("J")
								);
		List<CompletableFuture<String>> listFuture = new ArrayList<>();

		for (Dabing2 dabing2 : list) {
			CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> dabing2.laoZheng(), executor)
					.thenApply(e -> e.getName() + ": " + e.laoFan());
			listFuture.add(future);
		}
		List<String> results = listFuture.stream().map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 67.70133238190905, B: 93.327445420466, C: 80.98853579650296, D: 9.89354886325099, E: 66.33315575268045, F: 24.320805719321825, G: 65.34780373758679, H: 2.3678179401899424, I: 76.08893246211903, J: 89.53849243315845]

Total time: 2057ms

希望你对2秒钟的结果并不感到意外。

回到一开始的问题，现在假如线程不能（或者说不需要）切换CPU（比如说是CPU密集型的任务，没有等待时间，即使切换CPU，也无法提高性能），在这种情况下，烙10张饼需要多长时间？

为了模拟这种情况，我们只允许并发8个任务线程，每个任务线程一个CPU，这样就不会切换CPU了（会和主线程切换CPU，不过主线程忽略不计）。代码如下（只需把100改成8）：

第6次尝试：模拟禁止线程切换CPU的效果：

    private static final Executor executor = Executors.newFixedThreadPool(8, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
    });
	
	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"),
								new Dabing2("F"),
								new Dabing2("G"),
								new Dabing2("H"),
								new Dabing2("I"),
								new Dabing2("J")
								);
		List<CompletableFuture<String>> listFuture = new ArrayList<>();

		for (Dabing2 dabing2 : list) {
			CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> dabing2.laoZheng(), executor)
					.thenApply(e -> e.getName() + ": " + e.laoFan());
			listFuture.add(future);
		}
		List<String> results = listFuture.stream().map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 30.647253989773404, B: 11.389428951618285, C: 46.735632304796084, D: 49.74105190825268, E: 49.666923965637665, F: 80.69750116195178, G: 89.21920560287695, H: 98.87025808386537, I: 62.00460695058156, J: 47.47971523961366]

Total time: 4064ms

果然，又变成4秒钟了。

那么，怎么才能让结果像文章一开头提到的第2种方法那样，只用3秒钟呢？

答案是把thenApply()方法换成thenCompose()方法。

  • thenApply(): 和之前的Future在同一个线程里面串行工作；
  • thenCompose(): 把2个异步操作给串起来；

第7次尝试：使用thenCompose()方法：

    private static final Executor executor = Executors.newFixedThreadPool(8, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
    });
	
	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"),
								new Dabing2("F"),
								new Dabing2("G"),
								new Dabing2("H"),
								new Dabing2("I"),
								new Dabing2("J")
								);
		List<CompletableFuture<String>> listFuture = new ArrayList<>();

		for (Dabing2 dabing2 : list) {
			CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> dabing2.laoZheng(), executor)
					.thenCompose(e -> CompletableFuture.supplyAsync(() -> e.getName() + ": " + e.laoFan(), executor));
			listFuture.add(future);
		}
		List<String> results = listFuture.stream().map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

[A: 77.32257198460907, B: 94.7966134735508, C: 98.4247304567527, D: 58.687981756690675, E: 10.705884917172337, F: 2.66460909938242, G: 94.47073933921335, H: 97.08196979049613, I: 43.836353064485756, J: 92.17049504889374]

Total time: 3064ms

终于，实现了文章一开头所说的，烙3张饼最少需要3秒钟的情况。

第8次尝试，另一种写法：

	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"),
								new Dabing2("F"),
								new Dabing2("G"),
								new Dabing2("H"),
								new Dabing2("I"),
								new Dabing2("J")
								);
		
		List<CompletableFuture<String>> listFuture = list.stream().map(e -> CompletableFuture.supplyAsync(() -> e.laoZheng(), executor))
			.map(future -> future.thenCompose(e2 -> CompletableFuture.supplyAsync(() -> e2.getName() + ": " + e2.laoFan(), executor))).collect(Collectors.toList());
		
		List<String> results = listFuture.stream().map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(results);
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

结果也是一样的。

具体说来，烙完A的正面之后，并不会在同一个线程（碗）里烙A的反面，而是线程结束（碗清空）了，同时新启动了一个任务，去烙A的反面，也就是说这个任务是和其它任务来竞争线程（碗）的。

其实，在这种情况下，结果还是有一定的概率会出现4秒钟。因为大家都是在竞争，保不齐会出现A和B的正反面都烙好了，而C连一面还没有烙的情况。

另外再提一下另外一个方法：thenCombine()，它跟thenCompose()方法相似，也是把2个CompletableFuture对象串起来，但是后者要求二者有依赖关系，而前者则要求二者之间没有依赖关系。

最后提一下响应CompletableFuture的completion事件。在前面的代码中，都是等到所有的饼都烙好之后，才会打印出结果。如果希望在第一时间就有响应，也就是在第1张饼烙好之后就立刻告诉用户，该如何实现呢？

答案是使用thenAccept()方法，代码如下：

	public static void main(String args[]) {
		long starttime = System.nanoTime();
		List<Dabing2> list = Arrays.asList(new Dabing2("A"),
								new Dabing2("B"),
								new Dabing2("C"),
								new Dabing2("D"),
								new Dabing2("E"),
								new Dabing2("F"),
								new Dabing2("G"),
								new Dabing2("H"),
								new Dabing2("I"),
								new Dabing2("J")
								);
		
		Stream<CompletableFuture<String>> streamFuture = 
				list.stream().map(e -> CompletableFuture.supplyAsync(() -> e.laoZheng(), executor))
				.map(future -> future.thenCompose(e2 -> CompletableFuture.supplyAsync(() -> e2.getName() + ": " + e2.laoFan(), executor)));
			
		CompletableFuture[] futures = 
				streamFuture.map(f -> f.thenAccept(System.out::println)).toArray(size -> new CompletableFuture[size]);
		
		CompletableFuture.allOf(futures).join();
		
		long endtime = System.nanoTime();
		System.out.println("Total time: " + (endtime - starttime) / 1000000 + "ms");
	}

运行结果如下：

F: 2.4167631052547156

A: 56.264328725632616

D: 68.54896173377098

E: 0.6471072032815384

B: 97.82969628277193

C: 19.440428834510072

H: 14.132576179967293

G: 96.93087826713057

J: 15.148461531583257

I: 37.7317285366745

Total time: 3065ms

注：把线程数改小，比如1或者2，效果更加明显。

参考

Java 8 in Action: https://livebook.manning.com/book/java-8-in-action/

蓝黑2020
关注
专栏目录
Java中的异步编程：使用CompletableFuture
AI天才研究院
07-19 2838
作者：禅与计算机程序设计艺术 在Java中进行异步编程一直是一种困难甚至不可能的事情。由于各种历史原因、一些被遗忘的实现细节、线程池等问题导致了编写异步代码的困难和复杂性。最近的OpenJDK版本引入了一个新特性——CompletableFuture，它提供了一个全新的并发模型——Reactive Streams，用于编写响应式异步流处理
java future专题 2-1 CompletableFuture源码探秘-基础用法（1）
xxcupid的博客
04-01 436
todo
CompletableFuture详解~CompletionStage
小强快跑~~
02-26 1448
CompletableFuture 分别实现两个接口 Future与 CompletionStage。 Future 接口大家都比较熟悉，这里主要讲讲 CompletionStage。 CompletableFuture 大部分方法来自CompletionStage 接口，正是因为这个接口，CompletableFuture才有如此强大功能。 想要理解 CompletionStage 接口，我们需要先了解任务的时序关系的。我们可以将任务时序关系分为以下几种： 串行执行关系 并行
CompletableFuture回调机制的设计与实现
最新发布
张彦峰的博客
08-22 1万+
CompletableFuture回调机制的设计与实现：首先分析Future原理总述与局限性，再次分析CompletableFuture原理与回调机制总结，最后从类图分析、整体流程分析和算法实现分析CompletableFuture回调机制设计，结尾给出简单的使用CompletableFuture注意方面
Java8实战之（八）CompletableFuture： 组合式异步编程
weixin_42324034的博客
11-15 716
CompletableFuture： 组合式异步编程本章内容Future接口future 接口的局限性使用CompletableFuture构建异步应用实现异步API异常处理ֵ使用工厂方法supplyAsync创建CompletableFuture让你的代码免受阻塞之苦ֵ用 CompletableFuture 发起异步请求寻找更好的解决方案使用定制的执行器对多个异步任务进行流水线操作实现折扣服务 本章内容 创建异步计算、并获取最终的结果 使用非阻塞操作提升吞吐量 设计和实现异步API 如何以异步的方式使用
Java并发编程(六) CompletableFuture与CompletionStage使用
weixin_34129145的博客
09-18 698
2019独角兽企业重金招聘Python工程师标准>>> ...
使用CompletableFuture构建异步应用 （1）
duke_ding2的博客
06-14 171
背景 烙熟一张饼，需要正反面各烙1分钟。现在有一个铁锅，同时最多容纳2张饼。现在想要烙熟3张饼，问最少需要多长时间？ 答：最少需要3分钟。 假设3张饼分别为A、B、C，每张饼有x、y两面。第1种做法： Ax + Bx => Ax + By => Cx => Cy 则一共需要4分钟。 第2种做法： Ax + Bx => Ay + Cx => By + Cy 则一共只需要3分钟。 点评：第1种做法的缺点在于，在第3分钟的时候，C饼有两面要烙，铁锅也...
使用CompletableFuture构建异步应用(二)
栋先生
08-19 1211
获取商品价格的同步方法 将同步方法转换为异步方法 错误处理 本文主要介绍Java 8 中的异步处理的方式，主要是 CompletableFuture类的一些特性。 为了展示CompletableFuture的强大特性，我们会创建一个名为“最佳价格查询器” (best-price-finder)的应用，它会查询多个在线商店，依据给定的产品或服务找出最低的价格。这个过程中，你会学到...
CompletableFutureExamples:使用Java的CompletableFuture进行异步编程的示例
05-09
`CompletableFuture`是Java并发API的一部分，它构建于`Future`接口之上，但提供了更丰富的功能，包括链式调用、组合多个异步任务以及异常处理等。 `CompletableFuture`的核心特性在于它可以预先设置初始值，或者...
在Spring Boot2中使用CompletableFuture的方法教程
08-26
在Spring Boot 2中，`CompletableFuture`是一个强大的工具，用于构建异步、非阻塞的应用程序。结合`@Async`注解，可以轻松地实现并发处理，提高应用的性能和响应速度。本文将深入探讨如何在Spring Boot 2中有效地...
CompletableFuture 异步编排、案例及应用小案例
Trouvailless的博客
08-22 549
今天的话，就来以一个应用场景来进行一步一步的推导，在实现案例的过程中，将相关的知识点逐步讲述明白。应用场景如下：我们在查询掘金文章页面数据为应用场景，如何使用异步编程进行优化。//1. 文章内容信息 1s//2. 作者相关信息 0.5s 依赖于1的查询结果//3. 文章评论信息 0.5s 依赖于1的查询结果//4. 文章分类信息 0.5s 依赖于1的查询结果//5. 文章专栏信息 0.5s 依赖于1的查询结果//6. 相关文章信息 0.5s 依赖于1的查询结果//...复制代码补充。
从零开始学习CompletableFuture(一)基本使用
小哲的无何有镜
02-11 1045
Java8新特性 CompletableFuture的使用
不积硅步无以至千里
03-22 1305
下面两种方法的使用： CompletableFuture.supplyAsync 异步有返回值 CompletableFuture.runAsync异步无返回值 期望：对一个list集合中的每个元素加以处理（假设它们都是耗时操作），要求处理过程是异步并行的。对处理后的结果再次异步处理 步骤： 新建一个list 创建固定线程数的线程池 异步并行处理 list（同时会有五个守护线程异步去处理） 等待每个future任务完成 分别从每个future任务中取值（...
CompletableFuture用法详解
qq_36042938的博客
08-09 2804
小笔记
实现异步编程，这个工具类你得掌握！
月伴飞鱼
04-18 418
我们知道多线程能并发的处理多个任务，有效地提高复杂应用程序的性能，在实际开发中扮演着十分重要的角色 但是使用多线程也带来了很多风险，并且由线程引起的问题往往在测试中难以发现，到了线上就会造成重大的故障和损失 下面我会结合几个实际案例，帮助大家在工作做规避这些问题 多线程问题 首先介绍下使用的多线程会有哪些问题 使用多线程的问题很大程度上源于多个线程对同一变量的操作权，以及不同线程之间执行顺序的不确定性 《Java并发编程实战》这本书中提到了三种多线程的问题：安全性问题、活跃性问题和性能问题 安全性问题 例如
java 异步编程 CompletableFuture
m0_71149992的博客
06-17 3639
同步：就是在发出一个功能调用时，在没有得到结果之前，将一直处于等待中 即阻塞状态。也就是必须一件一件事做,等前一件做完了才能做下一件事异步：异步通常意味着非阻塞，可以使得我们的任务单独运行在与主线程分离的其他线程中，并且通过回调可以在主线程中得到异步任务的执行状态，是否完成，和是否异常等信息。 没有返回值的异步任务 有返回值的异步任务 thenAccept 消费处理结果, 接收任务的处理结果，并消费处理，无返回结果。 异常处理 exceptionally 异常
代替 Future 的 CompletableFuture让你的代码免受阻塞之苦
竹林幽深
01-12 415
IT牧场2022-01-11 21:20 点击下方“IT牧场”，选择“设为星标” IT牧场 IT牧场公众号，BAT 技术专家分享开发、架构、运维相关干货！ 159篇原创内容 公众号 作者 |何甜甜在吗 来源 |https://juejin.cn/post/6844904024332828685 通过阅读本篇文章你将了解到： CompletableFuture的使用 CompletableFure异步和同步的性能测试 已经有了Future为什么仍需要在J...
【JAVA8】CompletableFuture使用详解
胖虎儿的博客
08-22 1万+
CompletableFuture！让你的代码免受阻塞之苦！ 灵活的使用`CompletableFuture`可以让我们感受java8的异步编程之美!
并发编程--常用方法以及CompletableFuture
银魄清辉自夜凝的博客
11-23 346
常用方法 声明一个ExecutorService newCachedThreadPool = Executors.newCachedThreadPool(); ExecutorService方式：execute方法 new Runnable() 这样可以异步的执行Runnable里面的方法。 //异步方式一 @Override public void get1() { System.out.println("异步1"); newCachedThre
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值