CompletableFuture优化代码

runAsync、supplyAsync

区别

ExecutorService executor = Executors.newFixedThreadPool(5);

CompletableFuture.runAsync(() -> {
   System.out.println("无返回值");
}, executor);

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   System.out.println("有返回值");
   return "666";
}, executor);

**CompletableFuture.allOf (task1, task2).get ();**等待任务都完成

private static final ThreadPoolExecutor THREADPOOLEXECUTOR =
          new ThreadPoolExecutor (
                  100,
                  100,
                  100,
                  TimeUnit.SECONDS,
                  new ArrayBlockingQueue<> (1000));

  public static void main(String[] args) {
      RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes ();

      CompletableFuture<Void> task1 = CompletableFuture.runAsync (() -> {
          // 解决Feign异步调用丢失请求头的问题
          RequestContextHolder.setRequestAttributes (requestAttributes);

      }, THREADPOOLEXECUTOR);
      CompletableFuture<Void> task2 = CompletableFuture.runAsync (() -> {
          // 解决Feign异步调用丢失请求头的问题
          RequestContextHolder.setRequestAttributes (requestAttributes);

      }, THREADPOOLEXECUTOR);

      // 等待任务都完成
      try {
          CompletableFuture.allOf (task1, task2).get ();
      } catch (InterruptedException | ExecutionException e) {
          throw new RuntimeException (e);
      }

  }

**thenAcceptAsync()**方法：获取 上一个任务的结果

private static final ThreadPoolExecutor THREADPOOLEXECUTOR =
         new ThreadPoolExecutor (
                 100,
                 100,
                 100,
                 TimeUnit.SECONDS,
                 new ArrayBlockingQueue<> (1000));

 public static void main(String[] args) {
     RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes ();

     CompletableFuture<String> task1 = CompletableFuture.supplyAsync (() -> {
         // 解决Feign异步调用丢失请求头的问题
         RequestContextHolder.setRequestAttributes (requestAttributes);
         String mesage = "success";
         return mesage;
     }, THREADPOOLEXECUTOR);
     // res获取的是task1的返回值
     task1.thenAcceptAsync ((res) -> {
         System.out.println (res);
     }, THREADPOOLEXECUTOR);

 }

流式计算CompletableFuture优化代码

join()
等待 CompletableFuture 执行完成并获取其具体执行结果，可能
会抛出运行时异常，无需代码调用的地方手动 try...catch 进行
处理。

public PriceResult comparePriceInOnePlat2(List<String> products) {
      // 第一个流 并行处理，第二个流 处理结果！
      // 先触发各自平台的并行处理
      List<CompletableFuture<PriceResult>> completableFutures =
              products.stream()
                      .map(
                              product ->
                                      CompletableFuture
                                              .supplyAsync(
                                                      () -> HttpRequestMock.getMouBaoPrice(product), executor
                                              )
                                              .thenCombine(
                                                      CompletableFuture.supplyAsync(() -> HttpRequestMock.getMouBaoDiscounts(product), executor),
                                                      this::computeRealPrice
                                              )
                      )
                      .collect(Collectors.toList());
      // 在独立的流中，等待所有并行处理结束，做最终结果处理
      return completableFutures
              .stream()
              // join
              .map(CompletableFuture::join)
              // 排序
              .sorted(Comparator.comparingInt(PriceResult::getRealPrice))
              .findFirst()
              // 得到Optional对象，使用 get方法 取值
              .get();
  }