Java组合异步编程（1）

您好，我是湘王，这是我的CSDN博客，欢迎您来，欢迎您再来～

在《计算机干活的两种方式》中我们提到过同步和异步的区别。所谓同步就是事情只能一件接一件地顺着干，而不能跳过。比如外卖小哥送外卖只能一件一件地送，不能说一件先送一半再送另一件。而异步就可以不按顺序出牌，但是这种不按顺序需要以互不影响为前提。比如李雷问韩梅梅一个数学问题，但是韩梅梅一时答不出来，李雷就先去干其他的事情去了。等韩梅梅知道答案的时候，再给李雷打电话告诉他结果。就像这样子：

 

Java也支持这种异步工作模式。还是以代码来举例。

public static void doSomethingElse() {
	try {
		System.out.println("doSomethingElse...");
		Thread.sleep(1_000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
 
public static void executeComputation() {
	try {
		System.out.println("executeComputation...");
		Thread.sleep(2_000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
 
// 使用Future
public static void testExecutor() throws InterruptedException, ExecutionException {
	// 申请线程池执行
	ExecutorService es = Executors.newSingleThreadExecutor();
	Future f = es.submit(() -> {
		System.out.println(Thread.currentThread().getName());
		// 执行线程操作
		executeComputation();
		return 9527;
	});
	// 其他耗时操作
	doSomethingElse();
	System.out.println(f.get());
	es.shutdown();
}

运行代码后，也可以看到异步的执行痕迹。这可以用流程图来表示：

 

代码中的Futrure，就是那个可以通知李雷的「电话」。

那么问题来了，如果李雷有好几个不懂的问题，分别问了韩梅梅、赵梅梅、魏梅梅，而且需要答案之间有先后顺序怎么办呢？（比如要先得到韩梅梅的答案，再拿到赵梅梅的答案才有用）也就是对这种有多个「异步」任务的情况，该如何处理？这就是Java8中CompletableFuture（组合异步编程）要解决的问题。还是用代码来说话。

假如现在有三个异步任务，要求这三个异步任务能够「按顺序」执行，可以试着这么写：

ExecutorService service = Executors.newFixedThreadPool(3);
System.out.println("main start ...");
Future f1 = service.submit(() -> {
	System.out.println(Thread.currentThread().getName());
	// 执行线程操作
	executeComputation();
	return 9525;
});
Future f2 = service.submit(() -> {
	System.out.println(Thread.currentThread().getName());
	// 执行线程操作
	executeComputation();
	return 9526;
});
Future f3 = service.submit(() -> {
	System.out.println(Thread.currentThread().getName());
	// 执行线程操作
	executeComputation();
	return 9527;
});
System.out.println("main end ...");
service.shutdown();

但是运行之后发现，无论如何，「System.out.println("main end ...");」这行代码都不会最后执行，这就达不到「按顺序」执行的要求了。

现在换成CompletableFuture试试看：

ExecutorService service = Executors.newFixedThreadPool(3);
		System.out.println("main start ...");
		CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
			System.out.println("9525...");
			return 9525;
		}, service);
 
		CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
			System.out.println("9526...");
			return 9526;
		}, service);
 
		CompletableFuture future3 = CompletableFuture.supplyAsync(() -> {
			System.out.println("9527...");
			return 9527;
		}, service);
 
		CompletableFuture future = CompletableFuture.allOf(future1, future2, future3);
		future.get();
		System.out.println("main end ...");
		service.shutdown();

运行后会发现9525、9526、9527三个任务虽然都是异步任务，但能够「按顺序」排列，满足了最初的要求。

现在，更进一步，如果某个答案取决于两个不相干的问题的共同回答，该怎么实现呢？例如，李雷问韩梅梅，然后又问了赵梅梅，只有在都问她们两个人的情况下，她们才会说出答案，否则不给答案。

// 两个CompletableFuture，全部任务执行完成才返回
public static void testAllOf() throws InterruptedException, ExecutionException {
	CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
	CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "world");
 
	CompletableFuture combinedFuture = CompletableFuture.allOf(future1, future2);
	// 返回值是void，不会合并结果
	System.out.println(combinedFuture.get());
 
	// 需要手动处理每个并行异步任务的结果
	String combined = Stream.of(future1, future2)
							.map(CompletableFuture::join)
							.collect(Collectors.joining(" "));
	// hello world
	System.out.println(combined);
}

这就是神奇的CompletableFuture组合异步编程。可以通过代码让不同的问题强制「同频」，这算不算乱点鸳鸯谱？

当然，如果有同学觉得这很过分，也可以允许「只要有问了她们其中之一就立刻给答案」：

// 两个CompletableFuture，只要有一个任务执行完成就返回
public static void testAnyOf() throws InterruptedException, ExecutionException {
	CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
	CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
		try {
			Thread.sleep(2000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "world";
	});
	CompletableFuture