目录

• 使用工厂方法 supplyAsync创建 CompletableFuture
• 对比
• 对CompletableFuture async的理解

目前为止我们已经了解了如何通过编程创建 CompletableFuture 对象以及如何获取返回值，虽然看起来这些操作已经比较方便，但还有进一步提升的空间， CompletableFuture 类自身提供了大量精巧的工厂方法，使用这些方法能更容易地完成整个流程，还不用担心实现的细节。

可以看到我们使用new Thread的方式，显然是不恰当的。

使用工厂方法 supplyAsync创建 CompletableFuture

采用 supplyAsync 方法后，可以用一行代码重写getPriceAsync 方法。

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

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

supplyAsync 方法接受一个生产者（ Supplier ）作为参数，返回一个 CompletableFuture对象，该对象完成异步执行后会读取调用生产者方法的返回值。

生产者方法会交由 ForkJoinPool池中的某个执行线程（ Executor ）运行，但是你也可以使用 supplyAsync 方法的重载版本，传递第二个参数指定不同的执行线程执行生产者方法。

一般而言，向 CompletableFuture 的工厂方法传递可选参数，指定生产者方法的执行线程是可行的，后面我们会会介绍如何使用适合你应用特性的执行线程改善程序的性能。

对比

刚刚的代码

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

getPriceAsync 方法返回的 CompletableFuture 对象和 下面的代码

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;
}

手工创建和完成的 CompletableFuture 对象是完全等价的，这意味着它提供了同样的错误管理机制，而前者你花费了大量的精力才得以构建。

对CompletableFuture async的理解

验证代码如下

ExecutorService executorService = Executors.newFixedThreadPool(3);
        //executorService.submit(new RuleTestRunnable(1));
        List<Integer> taskList = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            taskList.add(i);
        }
        CompletableFuture<String> a1 = CompletableFuture.supplyAsync(() -> {
            logger.info("线程1{}{}","开始");
 
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            logger.info("线程1{}{}","结束");
            return "1";
        },executorService);
       CompletableFuture<String> a2 = CompletableFuture.supplyAsync(() -> {
 
            logger.info("线程2{}{}","开始");
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            logger.info("线程2{}{}","结束");
            return "1";
        },executorService);
        CompletableFuture<Object> a= a1.thenCombineAsync(a2,(s1,s2) -> {
            logger.info("组合线程{}{}");
            return  s1+s2;
        },executorService);
        Object result = a.get();

当executorService线程池大小为2时候，执行结果如下：

[pool-4-thread-1] INFO test.rcd.thread.CompletableFutureDemo.lambda$mains$4:127 - 组合线程{}{}

a1.thenCombineAsync方法始终被线程1或2执行

当executorService线程池大小为3时候,执行结果如下：

[pool-4-thread-3] INFO test.rcd.thread.CompletableFutureDemo.lambda$mains$4:127 - 组合线程{}{}

a1.thenCombineAsync方法始终被线程3执行

改为a1.thenCombine()，执行结果：

a1.thenCombineAsync方法始终被线程1或2执行

由此可见，async方法始终尝试取新线程执行方法，不带async方法则会从当前线程里取线程执行.CompletableFuture似是与线程无关的。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持自由互联。