在多任务程序中，我们比较熟悉的是分支-合并框架的并行计算，他的目的是将一个操作（比如巨大的List计算）切分为多个子操作，充分利用CPU的多核，甚至多个机器集群，并行执行这些子操作。
而CompletableFuture的目标是并发（执行多个操作），而非并行，是利用CPU的核，使其持续忙碌，达成最大吞吐，在并发进行中避免等待远程服务的返回值，或者数据库的长时查询结果等耗时较长的操作，如果解决了这些问题，就能获得最大的并发（通过避免阻塞）。
而分支-合并框架只是并行计算，是没有阻塞的情况。
Future接口
Future接口用于对将来某个时刻发生的结果进行建模，它建模了一种异步计算，返回一个执行结果的引用，计算完成后，这个引用被返回给调用方，
在使用Future时，将耗时操作封装在一个Callable接口对象中，提交给ExecutorService。
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}我们在异步执行结果获取时，设置了get过期时间2秒，否则，如果没有正常的返回值，会阻塞线程，非常危险。
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class FutureDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
Future<Integer> result = executor.submit(new Callable<Integer>() {
public Integer call() throws Exception {
Util.delay();
return new Random().nextInt();
}
});
doSomeThingElse();
executor.shutdown();
try {
try {
System.out.println("result:" + result.get(2,TimeUnit.SECONDS));
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
private static void doSomeThingElse() {
System.out.println("Do Some Thing Else." );
}
}因为Future的局限性，如
- 难异步合并
- 等待 Future 集合中的所有任务都完成。
- 仅等待 Future 集合中最快结束的任务完成，并返回它的结果。
一是我们没有好的方法去获取一个完成的任务；二是 Future.get 是阻塞方法，使用不当会造成线程的浪费。解决第一个问题可以用 CompletionService 解决，CompletionService 提供了一个 take() 阻塞方法，用以依次获取所有已完成的任务。对于第二个问题，可以用 Google Guava 库所提供的 ListeningExecutorService 和 ListenableFuture 来解决。这些都会在后面的介绍。
CompletableFuture组合异步
单一操作异步
我们的演示程序是查询多个在线商店，把最佳的价格返回给消费者。首先先查询一个产品的价格（即单一操作异步）。
先建一个同步模型商店类Shop，其中delay()是一个延时阻塞。
calculatePrice(String)同步输出一个随机价格，
getPriceAsync(String)是异步获取随机价格，依赖calculatePrice同步方法，返回类型是Future<Double>
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
public class Shop {
private final String name;
private final Random random;
public Shop(String name) {
this.name = name;
random = new Random(name.charAt(0) * name.charAt(1) * name.charAt(2));
}
public double getPrice(String product) {
return calculatePrice(product);
}
private double calculatePrice(String product) {
delay();
return random.nextDouble() * product.charAt(0) + product.charAt(1);
}
public Future<Double> getPriceAsync(String product) {
CompletableFuture<Double> futurePrice = new CompletableFuture<>();
new Thread( () -> {
double price = calculatePrice(product);
futurePrice.complete(price);
}).start();
return futurePrice;
}
public String getName() {
return name;
}
}delay()阻塞，延迟一秒，注释的代码是随机延迟0.5 - 2.5秒之间
public static void delay() {
int delay = 1000;
//int delay = 500 + RANDOM.nextInt(2000);
try {
Thread.sleep(delay);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}调用单一查询同步：
public class ShopSyncMain {
public static void main(String[] args) {
Shop shop = new Shop("BestShop");
long start = System.nanoTime();
double price = shop.getPrice("my favorite product");
System.out.printf("Price is %.2f%n", price);
long invocationTime = ((System.nanoTime() - start) / 1_000_000);
System.out.println("Invocation returned after " + invocationTime
+ " msecs");
// Do some more tasks
doSomethingElse();
long retrievalTime = ((System.nanoTime() - start) / 1_000_000);
System.out.println("Price returned after " + retrievalTime + " msecs");
}
private static void doSomethingElse() {
System.out.println("Doing something else...");
}
}
//结果：
Price is 123.26
Invocation returned after 1069 msecs
Doing something else...
Price returned after 1069 msecs嗯，一秒出头，这符合delay()阻塞一秒的预期
调用单一查询异步操作：
public class ShopMain {
public static void main(String[] args) {
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");
// Do some more tasks, like querying other shops
doSomethingElse();
// while the price of the product is being calculated
try {
double price = futurePrice.get();
System.out.printf("Price is %.2f%n", price);
} catch (ExecutionException | InterruptedException e) {
throw new RuntimeException(e);
}
long retrievalTime = ((System.nanoTime() - start) / 1_000_000);
System.out.println("Price returned after " + retrievalTime + " msecs");
}
private static void doSomethingElse() {
System.out.println("Doing something else...");
}
}结果：
Invocation returned after 54 msecs
Doing something else...
Price is 123.26
Price returned after 1102 msecs
咦，异步反而时间多了，别忘了，大家都是执行一个方法，不存在多个并发（也没有多个顺序流操作），异步当然显示不出优势。
异步异常
new Thread方式新建线程可能会有个糟糕的情况：用于提示错误的异常被限制在当前线程内，最终会杀死线程，所以get是无法返回期望值，client调用方会被阻塞。
你当然可以重载get，要求超时过期时间，可以解决问题，但你也应该解决这个错误逻辑，避免触发超时，因为超时又会触发TimeoutException，client永远不知道为啥产生了异常。
为了让client获知异常原因，需要对CompletableFuture对象使用completeExceptionally方法，将内部错误异常跑出。
改写如下：
public Future<Double> getPrice(String product) {
new Thread(() -> {
try {
double price = calculatePrice(product);
futurePrice.complete(price);
} catch (Exception ex) {
futurePrice.completeExceptionally(ex);
}
}).start();使用工厂方法创建CompletableFuture对象
前面用门通过手动建立线程，通过调用同步方法创建CompletableFuture对象，还可以通过CompletableFuture的工厂方法来方便的创建对象，重写如下：
public Future<Double> getPrice(String product) {
return CompletableFuture.supplyAsync(() -> calculatePrice(product));
}通过原生代码，我们可以了解supplyAsync和runAsync的区别，runAsync没有返回值，只是运行一个Runnable对象，supplyAsync有返回值U，参数是Supplier函数接口，或者可以自定义一个指定的执行线程池。
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
return asyncSupplyStage(asyncPool, supplier);
}
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
Executor executor) {
return asyncSupplyStage(screenExecutor(executor), supplier);
}
public static CompletableFuture<Void> runAsync(Runnable runnable) {
return asyncRunStage(asyncPool, runnable);
}
public static CompletableFuture<Void> runAsync(Runnable runnable,
Executor executor) {
return asyncRunStage(screenExecutor(executor), runnable);
}
并发单一任务异步
前面是单一的操作异步，异步的内涵不能显现，现在要查询一大堆的商店（并发）的同一产品的价格，然后对比价格。
商店List：
private final List<Shop> shops = Arrays.asList(new Shop("BestPrice"),
new Shop("LetsSaveBig"),
new Shop("MyFavoriteShop"),
new Shop("BuyItAll")/*,
new Shop("ShopEasy")*/);使用三种方式处理多个商店的价格查询：
//顺序同步方式
public List<String> findPricesSequential(String product) {
return shops.stream()
.map(shop -> shop.getName() + " price is " + shop.getPrice(product))
.collect(Collectors.toList());
}
//并行流方式
public List<String> findPricesParallel(String product) {
return shops.parallelStream()
.map(shop -> shop.getName() + " price is " + shop.getPrice(product))
.collect(Collectors.toList());
}
//工厂方法异步
public List<String> findPricesFuture(String product) {
List<CompletableFuture<String>> priceFutures =
shops.stream()
.map(shop -> CompletableFuture.supplyAsync(() -> shop.getName() + " price is "
+ shop.getPrice(product), executor))
.collect(Collectors.toList());
List<String> prices = priceFutures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return prices;
}
private final Executor executor = Executors.newFixedThreadPool(shops.size(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
});CompletableFuture::join的作用是异步的开启任务并发，并且将结果合并聚集。
结果：
sequential done in 4130 msecs
parallel done in 1091 msecs
composed CompletableFuture done in 1010 msecs
如果将list个数变成5个，结果是
同步必然是线性增长
sequential done in 5032 msecs
并行流受到PC内核数的限制（4个），所以一组并行只能指派最多4个线程，第二轮要多费时1秒多
parallel done in 2009 msecs
CompletableFuture异步方式能保持1秒的秘密在于线程池，我们定义了shops.size()大小的线程池，并且使用了守护线程。java提供了俩类的线程：用户线程和守护线程(user thread and Daemon thread)。用户线程是高优先级的线程。JVM虚拟机在结束一个用户线程之前，会先等待该用户线程完成它的task。
在另一方面，守护线程是低优先级的线程，它的作用仅仅是为用户线程提供服务。正是由于守护线程是为用户线程提供服务的，仅仅在用户线程处于运行状态时才需要守护线程。另外，一旦所有的用户线程都运行完毕，那么守护线程是无法阻止JVM退出的
并发多任务异步
假设所有商店开始折扣服务，用5种折扣码代表。
public class Discount {
public enum Code {
NONE(0), SILVER(5), GOLD(10), PLATINUM(15), DIAMOND(20);
private final int percentage;
Code(int percentage) {
this.percentage = percentage;
}
}
public static String applyDiscount(Quote quote) {
return quote.getShopName() + " price is " + Discount.apply(quote.getPrice(), quote.getDiscountCode());
}
private static double apply(double price, Code code) {
delay();
return format(price * (100 - code.percentage) / 100);
}
}
public class Quote {
private final String shopName;
private final double price;
private final Discount.Code discountCode;
public Quote(String shopName, double price, Discount.Code discountCode) {
this.shopName = shopName;
this.price = price;
this.discountCode = discountCode;
}
public static Quote parse(String s) {
String[] split = s.split(":");
String shopName = split[0];
double price = Double.parseDouble(split[1]);
Discount.Code discountCode = Discount.Code.valueOf(split[2]);
return new Quote(shopName, price, discountCode);
}
public String getShopName() {
return shopName;
}
public double getPrice() {
return price;
}
public Discount.Code getDiscountCode() {
return discountCode;
}
}比如，SILVER(5)代表95折, GOLD(10)代表90折，PLATINUM(15)代表85折。、
Quote类用于包装输出。同步的价格计算也做了修改，使用:来分割商店名、价格、折扣码。折扣码是随机产生的。
新的商店类，getPrice同步方法输出商店名、价格、折扣码的待分割字符串。parse用于将字符串转化为Quote实例。
打折延迟1秒。
public class Shop {
private final String name;
private final Random random;
public Shop(String name) {
this.name = name;
random = new Random(name.charAt(0) * name.charAt(1) * name.charAt(2));
}
public String getPrice(String product) {
double price = calculatePrice(product);
Discount.Code code = Discount.Code.values()[random.nextInt(Discount.Code.values().length)];
return name + ":" + price + ":" + code;
}
public double calculatePrice(String product) {
delay();
return format(random.nextDouble() * product.charAt(0) + product.charAt(1));
}
public String getName() {
return name;
}
}运行三种服务
public class BestPriceFinder {
private final List<Shop> shops = Arrays.asList(new Shop("BestPrice"),
new Shop("LetsSaveBig"),
new Shop("MyFavoriteShop"),
new Shop("BuyItAll"),
new Shop("ShopEasy"));
private final Executor executor = Executors.newFixedThreadPool(shops.size(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
});
//同步流
public List<String> findPricesSequential(String product) {
return shops.stream()
.map(shop -> shop.getPrice(product))
.map(Quote::parse)
.map(Discount::applyDiscount)
.collect(Collectors.toList());
}
//并行流
public List<String> findPricesParallel(String product) {
return shops.parallelStream()
.map(shop -> shop.getPrice(product))
.map(Quote::parse)
.map(Discount::applyDiscount)
.collect(Collectors.toList());
}
//CompletableFuture异步
public List<String> findPricesFuture(String product) {
List<CompletableFuture<String>> priceFutures = findPricesStream(product)
.collect(Collectors.<CompletableFuture<String>>toList());
return priceFutures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
}
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)));
}
public void printPricesStream(String product) {
long start = System.nanoTime();
CompletableFuture[] futures = findPricesStream(product)
.map(f -> f.thenAccept(s -> System.out.println(s + " (done in " + ((System.nanoTime() - start) / 1_000_000) + " msecs)")))
.toArray(size -> new CompletableFuture[size]);
CompletableFuture.allOf(futures).join();
System.out.println("All shops have now responded in " + ((System.nanoTime() - start) / 1_000_000) + " msecs");
}
}
//结果
sequential done in 10176 msecs
parallel done in 4010 msecs
composed CompletableFuture done in 2016 msecs
- 同步的10多秒是在5个list元素时获得的，每个一次询价，一次打折延迟，共2秒。
- 并行流一轮需要2秒多（第一轮询价4个+1个共两个轮次，2秒，第二轮打折4个+1个）。
- 异步方式第一轮和第二轮都是1秒多，所以2秒多。
这里的三步需要特别说明，这也是并发多任务的核心所在，并发是5条记录并发，多任务是
- 询价任务（耗时1秒）
- 解析字符换成Quote实例
- 计算折扣
这三个子任务
- .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)));
第一行是用异步工厂执行同步方法getPrice，返回字符串，涉及线程池；
第二行thenApply是将字符串转成Quote实例，这个是同步内存处理，不涉及线程池；
thenapply（）是接受一个Function<? super T,? extends U> fn参数用来转换CompletableFuture，相当于流的map操作，返回的是非CompletableFuture类型，它的功能相当于将CompletableFuture<T>转换成CompletableFuture<U>.
在这里是把CompletableFuture<String>转成CompletableFuture<Quote>
第三行也是异步处理，也涉及线程池，获得折扣后的价格。thenCompose（）在异步操作完成的时候对异步操作的结果进行一些操作,Function<? super T, ? extends CompletionStage<U>> fn参数，并且仍然返回CompletableFuture类型，相当于flatMap，用来连接两个CompletableFuture
如果加入一个不相互依赖的Future对象进行整合，比如需要计算汇率（不需要计算折扣，他们之间无依赖），可以试用thenCombine方法，这里有4种实现，最后一种比较优。
public class ExchangeService {
public enum Money {
USD(1.0), EUR(1.35387), GBP(1.69715), CAD(.92106), MXN(.07683);
private final double rate;
Money(double rate) {
this.rate = rate;
}
}
public static double getRate(Money source, Money destination) {
return getRateWithDelay(source, destination);
}
private static double getRateWithDelay(Money source, Money destination) {
delay();
return destination.rate / source.rate;
}
}
public List<String> findPricesInUSD(String product) {
List<CompletableFuture<Double>> priceFutures = new ArrayList<>();
for (Shop shop : shops) {
// Start of Listing 10.20.
// Only the type of futurePriceInUSD has been changed to
// CompletableFuture so that it is compatible with the
// CompletableFuture::join operation below.
CompletableFuture<Double> futurePriceInUSD =
CompletableFuture.supplyAsync(() -> shop.getPrice(product))
.thenCombine(
CompletableFuture.supplyAsync(
() -> ExchangeService.getRate(Money.EUR, Money.USD)),
(price, rate) -> price * rate
);
priceFutures.add(futurePriceInUSD);
}
// Drawback: The shop is not accessible anymore outside the loop,
// so the getName() call below has been commented out.
List<String> prices = priceFutures
.stream()
.map(CompletableFuture::join)
.map(price -> /*shop.getName() +*/ " price is " + price)
.collect(Collectors.toList());
return prices;
}
public List<String> findPricesInUSDJava7(String product) {
ExecutorService executor = Executors.newCachedThreadPool();
List<Future<Double>> priceFutures = new ArrayList<>();
for (Shop shop : shops) {
final Future<Double> futureRate = executor.submit(new Callable<Double>() {
public Double call() {
return ExchangeService.getRate(Money.EUR, Money.USD);
}
});
Future<Double> futurePriceInUSD = executor.submit(new Callable<Double>() {
public Double call() {
try {
double priceInEUR = shop.getPrice(product);
return priceInEUR * futureRate.get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
});
priceFutures.add(futurePriceInUSD);
}
List<String> prices = new ArrayList<>();
for (Future<Double> priceFuture : priceFutures) {
try {
prices.add(/*shop.getName() +*/ " price is " + priceFuture.get());
}
catch (ExecutionException | InterruptedException e) {
e.printStackTrace();
}
}
return prices;
}
public List<String> findPricesInUSD2(String product) {
List<CompletableFuture<String>> priceFutures = new ArrayList<>();
for (Shop shop : shops) {
// Here, an extra operation has been added so that the shop name
// is retrieved within the loop. As a result, we now deal with
// CompletableFuture<String> instances.
CompletableFuture<String> futurePriceInUSD =
CompletableFuture.supplyAsync(() -> shop.getPrice(product))
.thenCombine(
CompletableFuture.supplyAsync(
() -> ExchangeService.getRate(Money.EUR, Money.USD)),
(price, rate) -> price * rate
).thenApply(price -> shop.getName() + " price is " + price);
priceFutures.add(futurePriceInUSD);
}
List<String> prices = priceFutures
.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return prices;
}
public List<String> findPricesInUSD3(String product) {
// Here, the for loop has been replaced by a mapping function...
Stream<CompletableFuture<String>> priceFuturesStream = shops
.stream()
.map(shop -> CompletableFuture
.supplyAsync(() -> shop.getPrice(product))
.thenCombine(
CompletableFuture.supplyAsync(() -> ExchangeService.getRate(Money.EUR, Money.USD)),
(price, rate) -> price * rate)
.thenApply(price -> shop.getName() + " price is " + price));
// However, we should gather the CompletableFutures into a List so that the asynchronous
// operations are triggered before being "joined."
List<CompletableFuture<String>> priceFutures = priceFuturesStream.collect(Collectors.toList());
List<String> prices = priceFutures
.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList());
return prices;
}
来源：oschina
链接：https://my.oschina.net/u/4313515/blog/4187058