同步方法Pick異步方法查詢所有店鋪某個商品價格

店鋪為一個列表：

private static List<Shop> shopList = Arrays.asList(
        new Shop("BestPrice"),
        new Shop("LetsSaveBig"),
        new Shop("MyFavoriteShop"),
        new Shop("BuyItAll")
);

同步方法：

private static List<String> findPriceSync(String product) {
    return shopList.stream()
            .map(shop -> String.format("%s price is %.2f",
                    shop.getName(), shop.getPrice(product)))  //格式轉(zhuǎn)換
            .collect(Collectors.toList());
}

異步方法：

private static List<String> findPriceAsync(String product) {
    List<CompletableFuture<String>> completableFutureList = shopList.stream()
            //轉(zhuǎn)異步執(zhí)行
            .map(shop -> CompletableFuture.supplyAsync(
                    () -> String.format("%s price is %.2f",
                            shop.getName(), shop.getPrice(product))))  //格式轉(zhuǎn)換
            .collect(Collectors.toList());

    return completableFutureList.stream()
            .map(CompletableFuture::join)  //獲取結(jié)果不會拋出異常
            .collect(Collectors.toList());
}

性能測試結(jié)果：

Find Price Sync Done in 4141
Find Price Async Done in 1033

異步執(zhí)行效率提高四倍

為什么仍需要CompletableFuture

在JDK1.8以前，通過調(diào)用線程池的submit方法可以讓任務(wù)以異步的方式運行，該方法會返回一個Future對象，通過調(diào)用get方法獲取異步執(zhí)行的結(jié)果：

private static List<String> findPriceFutureAsync(String product) {
    ExecutorService es = Executors.newCachedThreadPool();
    List<Future<String>> futureList = shopList.stream().map(shop -> es.submit(() -> String.format("%s price is %.2f",
            shop.getName(), shop.getPrice(product)))).collect(Collectors.toList());

    return futureList.stream()
            .map(f -> {
                String result = null;
                try {
                    result = f.get();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }

                return result;
            }).collect(Collectors.toList());
}

既生瑜何生亮，為什么仍需要引入CompletableFuture？
對于簡單的業(yè)務(wù)場景使用Future完全沒有，但是想將多個異步任務(wù)的計算結(jié)果組合起來，后一個異步任務(wù)的計算結(jié)果需要前一個異步任務(wù)的值等等，使用Future提供的那點API就囊中羞澀，處理起來不夠優(yōu)雅，這時候還是讓CompletableFuture以聲明式的方式優(yōu)雅的處理這些需求

其他API介紹

whenComplete計算結(jié)果的處理：

對前面計算結(jié)果進(jìn)行處理，無法返回新值
提供了三個方法：

//方法一
public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)
//方法二
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
//方法三
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)

說明：

• BiFunction<? super T,? super U,? extends V> fn參數(shù) => 定義對結(jié)果的處理
• Executor executor參數(shù) => 自定義線程池
• 以async結(jié)尾的方法將會在一個新的線程中執(zhí)行組合操作

示例：

public class WhenCompleteTest {
    public static void main(String[] args) {
        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "hello");
        CompletableFuture<String> cf2 = cf1.whenComplete((v, e) ->
                System.out.println(String.format("value:%s, exception:%s", v, e)));
        System.out.println(cf2.join());
    }
}

thenApply轉(zhuǎn)換：

將前面計算結(jié)果的的CompletableFuture傳遞給thenApply，返回thenApply處理后的結(jié)果?？梢哉J(rèn)為通過thenApply方法實現(xiàn)CompletableFuture<T>至CompletableFuture<U>的轉(zhuǎn)換。白話一點就是將CompletableFuture的計算結(jié)果作為thenApply方法的參數(shù)，返回thenApply方法處理后的結(jié)果
提供了三個方法：

//方法一
public <U> CompletableFuture<U> thenApply(
    Function<? super T,? extends U> fn) {
    return uniApplyStage(null, fn);
}

//方法二
public <U> CompletableFuture<U> thenApplyAsync(
    Function<? super T,? extends U> fn) {
    return uniApplyStage(asyncPool, fn);
}

//方法三
public <U> CompletableFuture<U> thenApplyAsync(
    Function<? super T,? extends U> fn, Executor executor) {
    return uniApplyStage(screenExecutor(executor), fn);
}

說明：

• Function<? super T,? extends U> fn參數(shù) => 對前一個CompletableFuture 計算結(jié)果的轉(zhuǎn)化操作
• Executor executor參數(shù) => 自定義線程池
• 以async結(jié)尾的方法將會在一個新的線程中執(zhí)行組合操作
  示例：

public class ThenApplyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> result = CompletableFuture.supplyAsync(ThenApplyTest::randomInteger).thenApply((i) -> i * 8);
        System.out.println(result.get());
    }

    public static Integer randomInteger() {
        return 10;
    }
}

這里將前一個CompletableFuture計算出來的結(jié)果擴(kuò)大八倍

thenAccept結(jié)果處理：

thenApply也可以歸類為對結(jié)果的處理，thenAccept和thenApply的區(qū)別就是沒有返回值
提供了三個方法：

//方法一
public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
    return uniAcceptStage(null, action);
}

//方法二
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
    return uniAcceptStage(asyncPool, action);
}

//方法三
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action,
                                               Executor executor) {
    return uniAcceptStage(screenExecutor(executor), action);
}

說明：

• Consumer<? super T> action參數(shù) => 對前一個CompletableFuture計算結(jié)果的操作
• Executor executor參數(shù) => 自定義線程池
• 同理以async結(jié)尾的方法將會在一個新的線程中執(zhí)行組合操作
  示例：

public class ThenAcceptTest {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(ThenAcceptTest::getList).thenAccept(strList -> strList.stream()
                .forEach(m -> System.out.println(m)));
    }

    public static List<String> getList() {
        return Arrays.asList("a", "b", "c");
    }
}

將前一個CompletableFuture計算出來的結(jié)果打印出來

thenCompose異步結(jié)果流水化：

thenCompose方法可以將兩個異步操作進(jìn)行流水操作
提供了三個方法：

//方法一
public <U> CompletableFuture<U> thenCompose(
    Function<? super T, ? extends CompletionStage<U>> fn) {
    return uniComposeStage(null, fn);
}

//方法二
public <U> CompletableFuture<U> thenComposeAsync(
    Function<? super T, ? extends CompletionStage<U>> fn) {
    return uniComposeStage(asyncPool, fn);
}

//方法三
public <U> CompletableFuture<U> thenComposeAsync(
    Function<? super T, ? extends CompletionStage<U>> fn,
    Executor executor) {
    return uniComposeStage(screenExecutor(executor), fn);
}

說明：

• Function<? super T, ? extends CompletionStage<U>> fn參數(shù) => 當(dāng)前CompletableFuture計算結(jié)果的執(zhí)行
• Executor executor參數(shù) => 自定義線程池
• 同理以async結(jié)尾的方法將會在一個新的線程中執(zhí)行組合操作
  示例：

public class ThenComposeTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> result = CompletableFuture.supplyAsync(ThenComposeTest::getInteger)
                .thenCompose(i -> CompletableFuture.supplyAsync(() -> i * 10));
        System.out.println(result.get());
    }

    private static int getInteger() {
        return 666;
    }

    private static int expandValue(int num) {
        return num * 10;
    }
}

執(zhí)行流程圖：

thenCombine組合結(jié)果：

thenCombine方法將兩個無關(guān)的CompletableFuture組合起來，第二個Completable并不依賴第一個Completable的結(jié)果
提供了三個方法：

//方法一
public <U,V> CompletableFuture<V> thenCombine( 
    CompletionStage<? extends U> other,
    BiFunction<? super T,? super U,? extends V> fn) {
    return biApplyStage(null, other, fn);
}
  //方法二
  public <U,V> CompletableFuture<V> thenCombineAsync(
      CompletionStage<? extends U> other,
      BiFunction<? super T,? super U,? extends V> fn) {
      return biApplyStage(asyncPool, other, fn);
  }

  //方法三
  public <U,V> CompletableFuture<V> thenCombineAsync(
      CompletionStage<? extends U> other,
      BiFunction<? super T,? super U,? extends V> fn, Executor executor) {
      return biApplyStage(screenExecutor(executor), other, fn);
  }

說明：

• CompletionStage<? extends U> other參數(shù) => 新的CompletableFuture的計算結(jié)果
• BiFunction<? super T,? super U,? extends V> fn參數(shù) => 定義了兩個CompletableFuture對象完成計算后如何合并結(jié)果，該參數(shù)是一個函數(shù)式接口，因此可以使用Lambda表達(dá)式
• Executor executor參數(shù) => 自定義線程池
• 同理以async結(jié)尾的方法將會在一個新的線程中執(zhí)行組合操作

示例：

public class ThenCombineTest {
    private static Random random = new Random();
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> result = CompletableFuture.supplyAsync(ThenCombineTest::randomInteger).thenCombine(
                CompletableFuture.supplyAsync(ThenCombineTest::randomInteger), (i, j) -> i * j
        );

        System.out.println(result.get());
    }

    public static Integer randomInteger() {
        return random.nextInt(100);
    }
}

將兩個線程計算出來的值做一個乘法在返回
執(zhí)行流程圖：

allOf&anyOf組合多個CompletableFuture：

方法介紹：

//allOf
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {
    return andTree(cfs, 0, cfs.length - 1);
}
//anyOf
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {
    return orTree(cfs, 0, cfs.length - 1);
}

說明：

• allOf => 所有的CompletableFuture都執(zhí)行完后執(zhí)行計算。
• anyOf => 任意一個CompletableFuture執(zhí)行完后就會執(zhí)行計算

示例：

• allOf方法測試

  public class AllOfTest {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(() -> {
              System.out.println("hello");
              return null;
          });
          CompletableFuture<Void> future2 = CompletableFuture.supplyAsync(() -> {
              System.out.println("world"); return null;
          });
          CompletableFuture<Void> result = CompletableFuture.allOf(future1, future2);
          System.out.println(result.get());
      }
  }
  

  allOf方法沒有返回值，適合沒有返回值并且需要前面所有任務(wù)執(zhí)行完畢才能執(zhí)行后續(xù)任務(wù)的應(yīng)用場景
• anyOf方法測試

  public class AnyOfTest {
      private static Random random = new Random();
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
              randomSleep();
              System.out.println("hello");
              return "hello";});
          CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
              randomSleep();
              System.out.println("world");
              return "world";
          });
          CompletableFuture<Object> result = CompletableFuture.anyOf(future1, future2);
          System.out.println(result.get());
     }
  
      private static void randomSleep() {
          try {
              Thread.sleep(random.nextInt(10));
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }
  

  兩個線程都會將結(jié)果打印出來，但是get方法只會返回最先完成任務(wù)的結(jié)果。該方法比較適合只要有一個返回值就可以繼續(xù)執(zhí)行其他任務(wù)的應(yīng)用場景

注意點

很多方法都提供了異步實現(xiàn)【帶async后綴】，但是需小心謹(jǐn)慎使用這些異步方法，因為異步意味著存在上下文切換，可能性能不一定比同步好。如果需要使用異步的方法，先做測試，用測試數(shù)據(jù)說話?。。?/p>

CompletableFuture的應(yīng)用場景

存在IO密集型的任務(wù)可以選擇CompletableFuture，IO部分交由另外一個線程去執(zhí)行。Logback、Log4j2異步日志記錄的實現(xiàn)原理就是新起了一個線程去執(zhí)行IO操作，這部分可以以CompletableFuture.runAsync(()->{ioOperation();})的方式去調(diào)用，有關(guān)Logback異步日志記錄的原理可以參考這篇文章Logback異步日志記錄

優(yōu)化空間

supplyAsync執(zhí)行任務(wù)底層實現(xiàn)：

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    return asyncSupplyStage(asyncPool, supplier);
}
static <U> CompletableFuture<U> asyncSupplyStage(Executor e, Supplier<U> f) {
    if (f == null) throw new NullPointerException();
    CompletableFuture<U> d = new CompletableFuture<U>();
    e.execute(new AsyncSupply<U>(d, f));
    return d;
}

底層調(diào)用的是線程池去執(zhí)行任務(wù)，而CompletableFuture中默認(rèn)線程池為ForkJoinPool

private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();

ForkJoinPool線程池的大小取決于CPU的核數(shù)。之前寫的為什么阿里巴巴要禁用Executors創(chuàng)建線程池？文章中提及過，CPU密集型任務(wù)線程池大小配置為CPU核心數(shù)就可以了，但是IO密集型，線程池的大小由CPU數(shù)量 * CPU利用率 * (1 + 線程等待時間/線程CPU時間)確定。而CompletableFuture的應(yīng)用場景就是IO密集型任務(wù)，因此默認(rèn)的ForkJoinPool一般無法達(dá)到最佳性能，我們需自己根據(jù)業(yè)務(wù)創(chuàng)建線程池

最后附：示例代碼，歡迎Fork與Star

附往期文章：歡迎你的閱讀、點贊、評論

并發(fā)相關(guān)
1.為什么阿里巴巴要禁用Executors創(chuàng)建線程池？
2.自己的事情自己做，線程異常處理

設(shè)計模式相關(guān)：
1. 單例模式，你真的寫對了嗎？
2. (策略模式+工廠模式+map)套餐 Kill 項目中的switch case

JAVA8相關(guān)：
1. 使用Stream API優(yōu)化代碼
2. 親，建議你使用LocalDateTime而不是Date哦

數(shù)據(jù)庫相關(guān)：
1. mysql數(shù)據(jù)庫時間類型datetime、bigint、timestamp的查詢效率比較
2. 很高興！終于踩到了慢查詢的坑

高效相關(guān)：
1. 擼一個Java腳手架，一統(tǒng)團(tuán)隊項目結(jié)構(gòu)風(fēng)格

日志相關(guān)：
1. 日志框架，選擇Logback Or Log4j2？
2. Logback配置文件這么寫，TPS提高10倍

工程相關(guān)：
1. 閑來無事，動手寫一個LRU本地緩存
2. Redis實現(xiàn)點贊功能模塊
3. JMX可視化監(jiān)控線程池
4. 權(quán)限管理 【SpringSecurity篇】
5. Spring自定義注解從入門到精通
6. java模擬登陸優(yōu)酷
7. QPS這么高，那就來寫個多級緩存吧
8. java使用phantomjs進(jìn)行截圖

其他：
1. 使用try-with-resources優(yōu)雅關(guān)閉資源
2. 老板，用float存儲金額為什么要扣我工資