一、Future

初衷是对将来某个时刻会发生的结果进行建模.
想象成这样的场景：你拿了一袋子衣服到你中意的干洗店去洗。干洗店的员工会给你张发票，告诉你什么时候你的衣服会洗好（这就是一个Future事件）。衣服干洗的同时，你可以去做其他的事情。Future的另一个优点是它比更底层的Thread更易用。要使用Future，通常你只需要将耗时的操作封装在一个Callable对象中，再将它提交给ExecutorService，就万事大吉了。

ExecutorService executor = Executors.newCachedThreadPool();
Future<Double> future = executor.submit(new Callable<Double>() {public Double call() {return doSomeLongComputation();}
});
doSomethingElse();
try {//异步操作进行的同时， 你可以做其他的事情Double result = future.get(1, TimeUnit.SECONDS);} catch (ExecutionException ee) { // 计算抛出一个异常} catch (InterruptedException ie) { // 当前线程在等待过程中被中断} catch (TimeoutException te) { // 在Future对象完成之前超过已过期
}

这种编程方式让你的线程可以在ExecutorService以并发方式调用另一个线程执行耗时操作的同时，去执行一些其他的任务。

public class Shop {public double getPrice(String product) { // 待实现}
}模拟1秒钟延迟的方法
public static void delay() { try {Thread.sleep(1000L);} catch (InterruptedException e) { throw new RuntimeException(e);}
}public double getPrice(String product) { return calculatePrice(product);
}
private double calculatePrice(String product) { delay();return random.nextDouble() * product.charAt(0) + product.charAt(1);
}

1.1 Future 接口的局限性

将两个异步计算合并为一个——这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果。
等待Future集合中的所有任务都完成。
仅等待Future集合中最快结束的任务完成（有可能因为它们试图通过不同的方式计算同一个值），并返回它的结果。
通过编程方式完成一个Future任务的执行（即以手工设定异步操作结果的方式）。
应对Future的完成事件（即当Future的完成事件发生时会收到通知，并能使用Future 计算的结果进行下一步的操作，不只是简单地阻塞等待操作的结果）。

1.2 实现异步API

将同步方法转换为异步方法

你首先需要将getPrice转换为getPriceAsync方法，并修改它的返回值：
public Future<Double> getPriceAsync (String product){CompletableFuture<Double> futurePrice = new CompletableFuture<>();new Thread(() -> {double price = calculatePrice(product);futurePrice.complete(price);}).start();return futurePrice;
}

Shop shop = new Shop("BestShop");
long start = System.nanoTime();
Future<Double> futurePrice = shop.getPriceAsync("my favorite product");
long invocationTime = ((System.nanoTime() - start) / 1_000_000);
System.out.println("Invocation returned after " + invocationTime + " msecs");
// 执行更多任务，比如查询其他商店 doSomethingElse(); // 在计算商品价格的同时
try {double price = futurePrice.get();System.out.printf("Price is %.2f%n", price);
} catch (Exception e) {throw new RuntimeException(e);
}
long retrievalTime = ((System.nanoTime() - start) / 1_000_000);
System.out.println("Price returned after " + retrievalTime + " msecs");

错误处理

public Future<Double> getPriceAsync (String product){CompletableFuture<Double> futurePrice = new CompletableFuture<>();new Thread(() -> {try {double price = calculatePrice(product);futurePrice.complete(price);} catch (Exception ex) {futurePrice.completeExceptionally(ex);}}).start();return futurePrice;
}

使用工厂方法supplyAsync创建CompletableFuture对象

public Future<Double> getPriceAsync(String product) {
return CompletableFuture.supplyAsync(() -> calculatePrice(product));
}

让你的代码免受阻塞之苦

List<Shop> shops = Arrays.asList(new Shop("BestPrice"),
new Shop("LetsSaveBig"),
new Shop("MyFavoriteShop"),
new Shop("BuyItAll"));//采用顺序查询所有商店的方式实现的findPrices方法public List<String> findPrices(String product) { return shops.stream()
.map(shop -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product))) .collect(toList()); }
//time 4032//使用并行流对请求进行并行操作
public List<String> findPrices(String product) { return shops.parallelStream()
.map(shop -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product))) .collect(toList()); }
// time = 1180

使用 CompletableFuture 发起异步请求

//使用 CompletableFuture 发起异步请求
//工厂方法supplyAsync创建CompletableFuture对象
List<CompletableFuture<String>> priceFutures = shops.stream()
.map(shop -> CompletableFuture.supplyAsync( () -> String.format("%s price is %.2f", shop.getName(), shop.getPrice(product)))) .collect(toList());
//返回的是 List<CompletableFuture<String>>

使用这种方式，你会得到一个List<CompletableFuture>，列表中的每个 CompletableFuture对象在计算完成后都包含商店的String类型的名称。但是，由于你用 CompletableFutures实现的findPrices方法要求返回一个List，你需要等待所有的future执行完毕，将其包含的值抽取出来，填充到列表中才能返回。为了实现这个效果，你可以向最初的List<CompletableFuture>施加第二个map操作，对List中的所有future对象执行join操作，一个接一个地等待它们运行结束。注意 CompletableFuture类中的join方法和Future接口中的get有相同的含义，并且也声明在 Future接口中，它们唯一的不同是join不会抛出任何检测到的异常。
利用join();

使用CompletableFuture实现findPrices方法
public List<String> findPrices(String product) {
List<CompletableFuture<String>> priceFutures = shops.stream()
.map(shop -> CompletableFuture.supplyAsync( () -> shop.getName() + " price is " + shop.getPrice(product)))
.collect(Collectors.toList());
return priceFutures.stream().map(CompletableFuture::join)
.collect(toList());
}
//time = 2005

使用定制的执行器
我们建议你将执行器使用的线程数，与你需要查询的商店数目设定为同一个值

private final Executor executor =
Executors.newFixedThreadPool(Math.min(shops.size(), 100),
new ThreadFactory() {public Thread newThread(Runnable r) { Thread t = new Thread(r); t.setDaemon(true); return t;}
});

改进之后，使用CompletableFuture方案的程序处理5个商店仅耗时1021秒，处理9个商店
时耗时1022秒。一般而言，这种状态会一直持续，直到商店的数目达到我们之前计算的阈值400。这个例子证明了要创建更适合你的应用特性的执行器，利用CompletableFutures向其提交任务执行是个不错的主意。处理需大量使用异步操作的情况时，这几乎是最有效的策略。
注不设计io推荐实用steam 反之CompletableFuture灵活性更好

1.3 对多个异步任务进行流水线操作

构造同步和异步操作

ublic List<String> findPrices (String product){List<CompletableFuture<String>> priceFutures = shops.stream().map(shop -> CompletableFuture.supplyAsync(//使用另一个异 步任务构造期 望的Future， 申请折扣() -> shop.getPrice(product), executor)).map(future -> future.thenApply(Quote::parse)).map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor))).collect(toList());return priceFutures.stream().map(CompletableFuture::join).collect(toList());
}

第一个转换的结果是一个Stream<CompletableFuture>，一旦运行结束，每个CompletableFuture对象中都会包含对应shop返回的字符串。
将两个 CompletableFuture 对象整合起来，无论它们是否存在依赖

Future<Double> futurePriceInUSD =//通过乘法 整合得到 的商品价 格和汇率//创建第一个任务查询 商店取得商品的价格CompletableFuture.supplyAsync(() -> shop.getPrice(product)).thenCombine(CompletableFuture.supplyAsync(() -> exchangeService.getRate(Money.EUR, Money.USD)), (price, rate) -> price * rate);

对 Future 和 CompletableFuture 的回顾
利用Java 7的方法合并两个Future对象

ExecutorService executor = Executors.newCachedThreadPool();
final Future<Double> futureRate = executor.submit(new Callable<Double>() {public Double call() {//创建一个 查询欧元 到美元转 换汇率的 Futurereturn exchangeService.getRate(Money.EUR, Money.USD);}
});
Future<Double> futurePriceInUSD = executor.submit(new Callable<Double>() {public Double call() {double priceInEUR = shop.getPrice(product);return priceInEUR * futureRate.get();}
});

响应 CompletableFuture 的 completion 事件
重构findPrices方法返回一个由Future构成的流

public Stream<CompletableFuture<String>> findPricesStream(String product) {return 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)));
}

总结

以上是对组合异步编程章节部分笔记，前期工作需要对java8实战编制部分章节进行学习。后期再对章节进行补充完善。欢迎大佬指正。加油啊打工人们一起学习一起进步！

Java8实战笔记--组合异步编程相关推荐

现代化程序开发笔记(11)——异步编程杂谈
本系列文章以我的个人博客的搭建为线索(GitHub 仓库:Evian-Zhang/evian-blog),记录我在现代化程序设计中的一些笔记.在这篇文章中,我将以我的理解从头开始梳理一遍异步编程. 从 ...
java8 协程_Java8 异步编程—CompletableFuture
Java 为并发编程提供了众多的工具,本文将重点介绍 Java8 中 CompletableFuture. 笔者在自己搜索资料及实践之后,避开已经存在的优秀文章的写作内容与思路,将以更加浅显的示例和语 ...
Mcad学习笔记之异步编程(AsyncCallback委托,IAsyncResult接口,BeginInvoke方法,EndInvoke方法的使用小总结)...
收藏地址 http://aierong.cnblogs.com/archive/2005/05/25/162308.html 让我们来看看同步异步的区别: 同步方法调用在程序继续执行之前需要等待同步 ...
Mcad学习笔记之异步编程(AsyncCallback委托,IAsyncResult接口,Begin
http://www.chenjiliang.com/Article/View.aspx?ArticleID=2071 让我们来看看同步异步的区别: 同步方法调用在程序继续执行之前需要等待同步方法执 ...
《Java8实战》读书笔记10：组合式异步编程 CompletableFuture
<Java8实战>读书笔记10:组合式异步编程 CompletableFuture 第11章 CompletableFuture:组合式异步编程 11.1 Future 接口 (只是个引子 ...
《Java8实战》笔记（11）：CompletableFuture-组合式异步编程
CompletableFuture:组合式异步编程最近这些年,两种趋势不断地推动我们反思我们设计软件的方式. 第一种趋势和应用运行的硬件平台相关, 第二种趋势与应用程序的架构相关,尤其是它们之间如何 ...
java 8实战异步社区_服！看完阿里大牛手写的Java异步编程实战笔记，我惊呆了...
这份笔记涵盖了Java中常见的异步编程场景,包括单JVM内的异步编程.跨主机通过网络通信的远程过程调用的异步调用与异步处理,以及Web请求的异步处理等. 在讲解Java中每种异步编程技术时都附有案例, ...
《Java8实战》读书笔记06：Parallel Stream 并行流
<Java8实战>读书笔记06:Parallel Stream 并行流第7章并行数据处理与性能 7.1 并行流 7.1.1 将顺序流转换为并行流 7.1.2 测量流性能 7.1.3 正 ...
《Java8实战》笔记汇总
<Java8实战>笔记(01):为什么要关心Java8 <Java8实战>笔记(02):通过行为参数传递代码 <Java8实战>笔记(03):Lambda表达式 & ...

Java8实战笔记--组合异步编程

一、Future

1.1 Future 接口的局限性

1.2 实现异步API

1.3 对多个异步任务进行流水线操作

总结

Java8实战笔记--组合异步编程相关推荐

最新文章

热门文章