java线程池全部线程执行完后获取线程结果并分析demo

package com.common.bigData.last;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;
import java.util.concurrent.*;

public class LastDemo {
    private static Logger logger = LoggerFactory.getLogger(LastDemo.class);

    public static void main(String[] args) {
        List<Map.Entry<String, Integer>> mapList = new ArrayList<>();
        ConcurrentLinkedDeque concurrentLinkedDeque = new ConcurrentLinkedDeque();
        ExecutorService executorService=new ThreadPoolExecutor(10,20,
                60, TimeUnit.SECONDS,
                new  LinkedBlockingQueue<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            TaskCallable callable = new TaskCallable(i + "");
            Future f = executorService.submit(callable);
            concurrentLinkedDeque.addFirst(f);
        }
        logger.info("concurrentLinkedDeque.size "+concurrentLinkedDeque.size()+"");
        while (concurrentLinkedDeque.size() > 0) {
            Future<Map<String, Integer>> first = (Future<Map<String, Integer>>) concurrentLinkedDeque.getFirst();
            if (first.isDone()) { //保证任务执行完删除队列
                try {
                    Map<String, Integer> map = (Map<String, Integer>) first.get();
                    List<Map.Entry<String, Integer>> map2 = new ArrayList<>(map.entrySet());
                    mapList.addAll(map2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
                concurrentLinkedDeque.removeFirst();//在队列里删除该结果
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        List list2 =order(mapList);
        logger.info("over " + list2);
    }


    public static List order(List<Map.Entry<String,Integer>> mapList){
        Collections.sort(mapList, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o2.getValue()-o1.getValue();
            }
        });
        return mapList;
    }



    public static class TaskCallable  implements Callable {
        String id;

        public TaskCallable(String id) {
            this.id = id;
        }

        @Override
        public Object call() throws Exception {
            return single(Integer.parseInt(id));
        }

        private   Map<String,Integer> single(int i){
            logger.info("single "+i);
            Map<String,Integer> map=new HashMap<>();
            map.put(i+"a",i);
            map.put(i+"b",i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return map;
        }
    }
}