Java8新特性 CompletableFuture的使用

下面两种方法的使用：
        CompletableFuture.supplyAsync 异步有返回值

        CompletableFuture.runAsync 异步无返回值

期望：对一个list集合中的每个元素加以处理（假设它们都是耗时操作），要求处理过程是异步并行的。对处理后的结果再次异步处理

步骤：

1. 新建一个list
2. 创建固定线程数的线程池
3. 异步并行处理 list（同时会有五个守护线程异步去处理）
4. 等待每个future任务完成
5. 分别从每个future任务中取值（如果不等待所有任务完成后再调用 .get() 去取值，会造成任务队列阻塞），得到理想集合
6. 最后可再异步去处理得到的理想集合

public class Future {
    //创建固定线程数的线程池
    private static ExecutorService executor = Executors.newFixedThreadPool(5);
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"=================main线程开始==========="+ LocalTime.now());
//        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 2, 5,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable> (7));
        List<String> list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");

        //异步并行处理 list1（同时会有五个守护线程异步去处理）
        List<CompletableFuture<String>> collect = list.stream().map(s -> {
            CompletableFuture<String> async = CompletableFuture.supplyAsync(() -> {
                System.out.println(Thread.currentThread().getName() + "===========future线程开始=======" + LocalTime.now());
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "===========future线程结束=======" + LocalTime.now());
                return "S" + s;
            }, executor);
            return async;
        }).collect(Collectors.toList());

        //等待每个future任务完成
        CompletableFuture.allOf(collect.toArray(new CompletableFuture[collect.size()])).join();

        //分别从每个future任务中取值（如果不等待所有任务完成后再调用 .get() 去取值，会造成任务队列阻塞），得到理想集合
        List<String> collect1 = collect.stream().map(c -> {
            String s =null;
            try {
                   s = c.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            return s;
        }).collect(Collectors.toList());

        //最后可再异步去处理得到的理想集合
        CompletableFuture.runAsync(() -> {
            List<String> collect2 = collect1.stream().map(c -> {
                String S = c + "S";
                return S;
            }).collect(Collectors.toList());
            System.out.println(Thread.currentThread().getName()+"===========所有任务完成======="+LocalTime.now()+"===============获取值"+collect2);
        });
        System.out.println(Thread.currentThread().getName()+"===========所有任务完成======="+LocalTime.now()+"===============获取值"+collect1);
        System.out.println(Thread.currentThread().getName()+"=================main线程结束==========="+ LocalTime.now());
    }
}

结果：