-
Java组合异步编程（1）
在《计算机干活的两种方式》中我们提到过同步和异步的区别。所谓同步就是事情只能一件接一件地顺着干，而不能跳过。比如外卖小哥送外卖只能一件一件地送，不能说一件先送一半再送另一件。而异步就可以不按顺序出牌，但是这种不按顺序需要以互不影响为前提。比如李雷问韩梅梅一个数学问题，但是韩梅梅一时答不出来，李雷就先去干其他的事情去了。等韩梅梅知道答案的时候，再给李雷打电话告诉他结果。就像这样子：
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<Integer> 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<Integer> f1 = service.submit(() -> {
System.out.println(Thread.currentThread().getName());
// 执行线程操作
executeComputation();
return 9525;
});
Future<Integer> f2 = service.submit(() -> {
System.out.println(Thread.currentThread().getName());
// 执行线程操作
executeComputation();
return 9526;
});
Future<Integer> 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<Integer> future1 = CompletableFuture.supplyAsync(() -> {
System.out.println("9525...");
return 9525;
}, service);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("9526...");
return 9526;
}, service);
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
System.out.println("9527...");
return 9527;
}, service);
CompletableFuture<Void> 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<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
CompletableFuture<Void> 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<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
return "world";
});
CompletableFuture<Object> combinedFuture = CompletableFuture.anyOf(future1, future2);
// Hello World
System.out.println(combinedFuture.get());
}
这更像唐伯虎点秋香中最后揭盖头的场景——只要揭了一个，剩下的全部自己揭开。
出处：https://www.cnblogs.com/xiangwang1111/p/16875136.html
