目前為止我們已經了解了如何通過編程創建 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似是與線程無關的。

以上為個人經驗，希望能給大家一個參考，也希望大家多多支持服務器之家。

原文鏈接：https://artisan.blog.csdn.net/article/details/115502313