一、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() {
//创建一个 查询欧元 到美元转 换汇率的 Future
return 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实战编制部分章节进行学习。后期再对章节进行补充完善。欢迎大佬指正。 加油啊 打工人们一起学习一起进步！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
