// 可以執(zhí)行Executors異步執(zhí)行，如果不指定，默認使用ForkJoinPool
CompletableFuture.runAsync(() -> System.out.println("Hello CompletableFuture!"));

// 同樣可以指定線程池
CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> "Hello CompletableFuture!");
System.out.println(stringCompletableFuture.get());

// Demo
       CompletableFuture
                .supplyAsync(() -> "Hello CompletableFuture!")
                // 針對上一步的結果做處理，產(chǎn)生新的結果
                .thenApplyAsync(s -> s.toUpperCase())
                // 針對上一步的結果做處理，不返回結果
                .thenAcceptAsync(s -> System.out.println(s))
                // 不需要上一步返回的結果，直接進行操作
                .thenRunAsync(() -> System.out.println("end"));
        ;

// 返回abc
CompletableFuture
                .supplyAsync(() -> {
                    SleepUtils.sleep(100);
                    return "Hello CompletableFuture!";
                })
                .acceptEither(CompletableFuture.supplyAsync(() -> "abc"), new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                });
// 返回Hello CompletableFuture!       
CompletableFuture
                .supplyAsync(() -> "Hello CompletableFuture!")
                .acceptEither(CompletableFuture.supplyAsync(() -> {
                    SleepUtils.sleep(100);
                    return "abc";
                }), new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                });

        CompletableFuture<Integer> heightAsync = CompletableFuture.supplyAsync(() -> 172);

        CompletableFuture<Double> weightAsync = CompletableFuture.supplyAsync(() -> 65)
                .thenCombine(heightAsync, new BiFunction<Integer, Integer, Double>() {
                    @Override
                    public Double apply(Integer wight, Integer height) {
                        return wight * 10000.0 / (height * height);
                    }
                })
                ;

// thenAcceptBoth案例：
        CompletableFuture
                .supplyAsync(() -> "Hello CompletableFuture!")
                .thenAcceptBoth(CompletableFuture.supplyAsync(() -> "abc"), new BiConsumer<String, String>() {
                		// 參數(shù)一為我們剛開始運行時的CompletableStage，新傳入的作為第二個參數(shù)
                    @Override
                    public void accept(String s, String s2) {
                        System.out.println("param1=" + s + ", param2=" + s2);
                    }
                });
// 結果：param1=Hello CompletableFuture!, param2=abc

        CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("發(fā)生錯誤");
        }).exceptionally(throwable -> {
            log.error("調(diào)用錯誤 {}", throwable.getMessage(), throwable);
            return "異常處理內(nèi)容";
        });

CompletableFuture.supplyAsync(() -> {
    return "abc";
})
.handle((r,err) -> {
    log.error("調(diào)用錯誤 {}", err.getMessage(), err);
    // 對結果做額外的處理
    return r;
})
;

  // 假設有500萬條記錄
        long recordCount = 500 * 10000;
        int subTaskRecordCount = 10000;
        // 對記錄進行分片
        List<Map> subTaskList = new LinkedList<>();
        for (int i = 0; i < recordCount / 500; i++) {
            // 如果子任務結構復雜，建議使用對象
            HashMap<String, Integer> subTask = new HashMap<>();
            subTask.put("index", i);
            subTask.put("offset", i * subTaskRecordCount);
            subTask.put("count", subTaskRecordCount);
            subTaskList.add(subTask);
        }

  // 進行subTask批量處理，拆分為不同的任務
        subTaskList.stream()
                .map(subTask -> CompletableFuture.runAsync(()->{
                    // 讀取數(shù)據(jù)，然后處理
                    // dataTunel.read(subTask);
                },excuturs))   // 使用應用的通用任務線程池
                .map(c -> ((CompletableFuture<?>) c).join());

     List<Task> taskList = new ArrayList<>();
        List<Object> result = taskList.stream()
                .map(task -> CompletableFuture.supplyAsync(()->{
//                    handlerMap.get(task).query();
                    return "";
                }, executorService))
                .map(c -> c.join())
                .collect(Collectors.toList());