【小家Java】Future、FutureTask、CompletionService、CompletableFuture解决多线程并发中归集问题的效率对比（中）

/**
 * CompletionService多线程并发任务结果归集
 *
 * @author fangshixiang@vipkid.com.cn
 * @description //
 * @date 2018/10/31 11:29
 */
public class CompletionServiceDemo {
    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //开启10个线程
        ExecutorService exs = Executors.newFixedThreadPool(10);
        //结果集
        List<Integer> list = new ArrayList<>();
        List<Future<Integer>> futureList = new ArrayList<>();
        try {
            int taskCount = 10;
            //1.定义CompletionService ExecutorCompletionService是此接口的唯一实现类 需要把线程池传进去
            CompletionService<Integer> completionService = new ExecutorCompletionService<>(exs);
            //2.添加任务（向CompletionService添加任务 然后把返回的futrue添加到futureList即可）
            for (int i = 0; i < taskCount; i++) {
                futureList.add(completionService.submit(new Task(i + 1)));
            }
            //==================结果归集===================
            //方法1：future是提交时返回的，遍历queue则按照任务提交顺序，获取结果  (若是按照提交顺序，那和Futrue的Demo结果将一样，没啥优势可言)
//            for (Future<Integer> future : futureList) {
//                System.out.println("====================");
//                Integer result = future.get();//线程在这里阻塞等待该任务执行完毕,按照
//                System.out.println("任务result="+result+"获取到结果!"+new Date());
//                list.add(result);
//            }
//            //方法2.使用内部阻塞队列的take()：内部维护阻塞队列，任务先完成的先获取到
            for (int i = 0; i < taskCount; i++) {
                Integer result = completionService.take().get();//采用completionService.take()，
                System.out.println("任务i==" + result + "完成!" + new Date());
                list.add(result);
            }
            System.out.println("list=" + list);
            System.out.println("总耗时=" + (System.currentTimeMillis() - start));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            exs.shutdown();//关闭线程池
        }
    }
    static class Task implements Callable<Integer> {
        Integer i;
        public Task(Integer i) {
            super();
            this.i = i;
        }
        @Override
        public Integer call() throws Exception {
            if (i == 5) {
                Thread.sleep(5000);
            } else {
                Thread.sleep(1000);
            }
            System.out.println("线程：" + Thread.currentThread().getName() + "任务i=" + i + ",执行完成！");
            return i;
        }
    }
}

线程：pool-1-thread-4任务i=4,执行完成！
任务i==4完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-3任务i=3,执行完成！
任务i==3完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-2任务i=2,执行完成！
任务i==2完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-1任务i=1,执行完成！
任务i==1完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-8任务i=8,执行完成！
任务i==8完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-7任务i=7,执行完成！
任务i==7完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-6任务i=6,执行完成！
任务i==6完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-10任务i=10,执行完成！
任务i==10完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-9任务i=9,执行完成！
任务i==9完成!Wed Oct 31 11:33:35 CST 2018
线程：pool-1-thread-5任务i=5,执行完成！
任务i==5完成!Wed Oct 31 11:33:39 CST 2018
list=[4, 3, 2, 1, 8, 7, 6, 10, 9, 5] ---》这里证实了确实按照执行完成顺序排序
总耗时=5019 ---》符合逻辑，10个任务，定长5线程池执行，取最长时间。

   public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }
    public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
    }
    public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
    }

    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);
    }

    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);
    }