ExecutorCompletionService详解

1 什么场景下适用？

针对需要获取线程池执行完后获取结果，看下面这个例子：

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程池
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(5, Integer.MAX_VALUE,
        60L, TimeUnit.SECONDS,
                new SynchronousQueue<>());
        //存储FutrueTask结果
        ArrayList<Future<Integer>> taskList = new ArrayList<>();
        for(int i=0;i<5;i++){
            int j = i;
            //执行任务
            Future<Integer> task = executorService.submit(() -> {
                try{
                    //任务执行时长
                    Thread.sleep((10-j)*1000);
                }catch (Exception e){}
                return (10-j)*1000;
            });
            taskList.add(task);
        }
        //处理多线程返回得结果集
        for(Future<Integer> future : taskList){
            System.out.println(future.get());
        }
    }
    输出结果：
    10000
	9000
	8000
	7000
	6000

上面Future的get方法是个阻塞方法，只有当线程执行完毕才能获取到值，由于首个线程执行的时间最长，会一直等待其执行完毕才能输出后面的线程执行结果(不要有倒序遍历就能输出先执行完这样想法，这里只是举例子，实际业务不一定先放入集合中业务最后执行完)。那如何获取先执行完毕的线程结果呢？我们看下ExecutorCompletionService这个类。

2 构造方法

入参为一个线程池对象。

    public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        //判断当前线程池对象是不是AbstractExecutorService的实例，如果是则给aes对象赋值，否则为null
        //这里的aes主要用于后面创建FutureTask对象创建的判断
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        //创建一个阻塞队列用于存储返回的Future对象
        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
    }

还有个重载得构造方法，需要传入指定得阻塞队列

    public ExecutorCompletionService(Executor executor,
                                     BlockingQueue<Future<V>> completionQueue) {
        if (executor == null || completionQueue == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = completionQueue;
    }

3 submit方法

newTaskFor方法创建RunnableFuture对象得逻辑参考这个文章：https://blog.csdn.net/fgtCSDN/article/details/131973128，我们这里主要看下QueueingFuture对象。

    public Future<V> submit(Callable<V> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task);
        executor.execute(new QueueingFuture(f));
        return f;
    }

    public Future<V> submit(Runnable task, V result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task, result);
        executor.execute(new QueueingFuture(f));
        return f;
    }

4 QueueingFuture对象

该对象继承了FutureTask对象，相当于实现了runnable接口，故可以被线程池的excute执行。

		QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;

其中的done()方法是一个重写方法，FutureTask对象的该方法为空，其被调用在设置返回值之后，也就是说当任务执行完毕之后就会将当前RunnableFuture返回值放到阻塞队列中。

5 ExecutorCompletionService应用

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程池
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(5, Integer.MAX_VALUE,
        60L, TimeUnit.SECONDS,
                new SynchronousQueue<>());
        ExecutorCompletionService<Integer> completionService = new ExecutorCompletionService<>(executorService);
        //存储FutrueTask结果
        for(int i=0;i<5;i++){
            int j = i;
            //执行任务
           completionService.submit(() -> {
                //这里可以执行具体得业务并返回
                try{
                    Thread.sleep((10-j)*1000);
                }catch (Exception e){}
                return (10-j)*1000;
            });
        }
        //处理多线程返回得结果集
        Future<Integer> aa;
        while ((aa =completionService.take()) !=null){
            System.out.println(aa.get());
        }
    }
    输出结果：
    6000
	7000
	8000
	9000
	10000

上面的输出结果可以看出，先执行完的线程结果优先输出了。