使用CompletableFuture进行多任务并行处理

话不多说，上代码！

package com.example.demo.research.async;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.function.Supplier;

public class CompletableFutureDemo {

    /**
     * CPU核数
     */
    private static final int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();

    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            AVAILABLE_PROCESSORS,  //核心线程数
            3 * AVAILABLE_PROCESSORS,  //最大线程数
            3, TimeUnit.SECONDS,  //keepAliveTime
            new LinkedBlockingDeque<>(20));  //阻塞队列


    public static void main(String[] args) throws Exception {
        long startTime = System.currentTimeMillis();
        System.out.println("demo start....." + startTime);

        demo4();

        System.out.println("demo end.....costTime = " + (System.currentTimeMillis() - startTime));
    }

    /**
     * 基于allOf，并行处理多个任务，等待所有任务执行完毕后返回
     */
    public static void demo3() throws Exception {
        //用于整体接收各个任务的返回值
        Map dataMap = new HashMap<>();

        List> futureList = new ArrayList<>();
        futureList.add(doSomethingA("A", dataMap));
        futureList.add(doSomethingB("B", dataMap));
        futureList.add(doSomethingC("C", dataMap));

        CompletableFuture result = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[futureList.size()]));

        try {
            result.get(2, TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("result = " + dataMap);
        //结果为：{doSomeThingB=B, doSomeThingA=A}
    }

    /**
     * 基于thenCompose，第一个任务执行完后，第二个任务使用第一个任务的返回作为参数
     */
    public static void demo1() throws Exception {
        Map dataMap = new HashMap<>();

        CompletableFuture completableFuture = doSomethingA("A", dataMap)
                .thenCompose(id -> doSomethingB(id, dataMap));

        String result = completableFuture.get(2, TimeUnit.SECONDS);
        System.out.println("result = " + result);
        //结果为：A is done is done
    }

    /**
     * 基于thenCombine，当两个任务都完成后，使用两者的结果作为参数再执行一个异步任务
     */
    public static void demo2() throws Exception {
        Map dataMap = new HashMap<>();

        CompletableFuture completableFuture = doSomethingA("A", dataMap)
                .thenCombine(doSomethingB("B", dataMap), (a, b) -> a + " - " + b);

        String result = completableFuture.get(2, TimeUnit.SECONDS);
        System.out.println("result = " + result);
        //结果为：A is done - B is done
    }


    /**
     * 使用CompletionService批量异步处理
     *
     * CompletionService 能够让异步任务的执行结果有序化，先执行完的先进入阻塞队列，
     * 利用这个特性，你可以轻松实现后续处理的有序性，避免无谓的等待
     */
    public static void demo4() {
        Map dataMap = new HashMap<>();

        CompletionService