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

最新推荐文章于 2024-05-29 13:27:48 发布

文刀_刘

最新推荐文章于 2024-05-29 13:27:48 发布

阅读量239

点赞数 2

分类专栏：学习笔记

本文链接：https://blog.csdn.net/qq_43584064/article/details/115611525

版权

学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、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实战编制部分章节进行学习。后期再对章节进行补充完善。欢迎大佬指正。加油啊打工人们一起学习一起进步！

文刀_刘

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java8实战笔记--组合异步编程

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

扫一扫

专栏目录