CompletableFuture（二）
转载自：http://www.jb51.net/article/51163.htm
创造和获取CompletableFuture
static CompletableFuture supplyAsync(Supplier supplier);
static CompletableFuture supplyAsync(Supplier supplier, Executor executor);
static CompletableFuture runAsync(Runnable runnable);
static CompletableFuture runAsync(Runnable runnable, Executor executor); 转换和作用于CompletableFuture(thenApply)
CompletableFuture优于Future，因为CompletableFuture是一个原子也是一个因子。Scala和JavaScript都允许future完成时允许注册异步回调，直到它准备好才要等待和阻止它。可以简单地说：运行这个函数时就出现了结果。此外，可以叠加这些功能，把多个future通过thenApply()组合在一起：ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
return "zero";
}, executor);
CompletableFuture f2 = f1.thenApply(new Function() {
@Override
public Integer apply(String t) {
System.out.println(t);
return Integer.valueOf(t.length());
}
});
CompletableFuture f3 = f2.thenApply(r -> r * 2.0);
System.out.println(f3.get()); zero
8.0运行完成的代码（thenAccept/thenRun）
CompletableFuture thenAccept(Consumer block);
CompletableFuture thenRun(Runnable action); 单个CompletableFuture的错误处理
CompletableFuture safe = future.exceptionally(ex -> "We have a problem: " + ex.getMessage()); CompletableFuture future = f2.thenApply(r -> r * 2.0);
future.handle(new BiFunction(){
@Override
public Double apply(Double t, Throwable u) {
if (t != null) {
System.out.println("handler");
return t;
}else {
System.out.println(u);
return -1.0;
}
}
}
结合（链接）两个futures（thenCompose()）
有时想运行一些future的值（当它准备好了），但这个函数也返回了future。CompletableFuture足够灵活地明白函数结果现在应该作为顶级的future，对比CompletableFuture thenCompose(Function> fn);//（CompletableFuture extends CompletionStage）
public static void f5() throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
return "zero";
}, executor);
CompletableFuture> f4 = f1.thenApply(CompletableFutureTest::calculate);
System.out.println(f4.get().get());
CompletableFuture f5 = f1.thenCompose(CompletableFutureTest::calculate);
System.out.println(f5.get());
System.out.println(f1.get());
}
public static CompletableFuture calculate(String input) {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println(input);
return input + "---" + input.length();
}, executor);
return future;
} 两个futures的转换值(thenCombine())
当thenCompose()用于链接一个future时依赖另一个thenCombine，当他们都完成之后就结合两个独立的futures：public CompletableFuture thenCombine(
CompletionStage other,
BiFunction fn) CompletableFuture customerFuture = loadCustomerDetails(123);
CompletableFuture shopFuture = closestShop();
CompletableFuture routeFuture =
customerFuture.thenCombine(shopFuture, (cust, shop) -> findRoute(cust, shop));
private Route findRoute(Customer customer, Shop shop) //... customerFuture.thenCombine(shopFuture, this::findRoute);ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
return "zero";
}, executor);
CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
return "hello";
}, executor);
CompletableFuture reslutFuture =
f1.thenCombine(f2, new BiFunction() {
@Override
public String apply(String t, String u) {
return t.concat(u);
}
});
System.out.println(reslutFuture.get());//zerohello 等待所有的 CompletableFutures 完成
如果不是产生新的CompletableFuture连接这两个结果，我们只是希望当完成时得到通知，我们可以使用 thenAcceptBoth()/runAfterBoth()系列的方法。它们的工作方式与thenAccept() 和 thenRun()类似，但是是等待两个futures而不是一个：public CompletableFuture thenAcceptBoth(
CompletionStage other,
BiConsumer action)
public CompletableFuture runAfterBoth(CompletionStage other,
Runnable action) ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "zero";
}, executor);
CompletableFuture f2 = CompletableFuture.supplyAsync(() -> {
try {
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return "hello";
}, executor);
CompletableFuture reslutFuture = f1.thenAcceptBoth(f2, new BiConsumer() {
@Override
public void accept(String t, String u) {
System.out.println(t + " over");
System.out.println(u + " over");
}
});
System.out.println(reslutFuture.get()); zero over
hello over
null等待第一个 CompletableFuture 来完成任务
另一个有趣的事是CompletableFutureAPI可以等待第一个（与所有相反）完成的future。当有两个相同类型任务的结果时就显得非常方便，只要关心响应时间就行了，没有哪个任务是优先的。public CompletableFuture acceptEither(CompletionStage other,
Consumer action)
public CompletableFuture runAfterEither(CompletionStage other,
Runnable action) 完整地转换第一个系统
applyToEither()算是 acceptEither()的前辈了。当两个futures快要完成时，后者只是简单地调用一些代码片段，applyToEither()将会返回一个新的future。当这两个最初的futures完成时，新的future也会完成。 public CompletableFuture applyToEither(CompletionStage other,
Function fn)多种结合的CompletableFuture
知道如何等待两个future来完成（使用thenCombine()）并第一个完成(applyToEither())。但它可以扩展到任意数量的futures吗？的确，使用static辅助方法：public static CompletableFuture allOf(CompletableFuture... cfs)
public static CompletableFuture