共同学习Java源代码-多线程与并发-CompletionService接口和ExecutorCompletionService类

这个接口用来将生产新异步任务和消费已完成任务进行解耦

    Future<V> submit(Callable<V> task);

    Future<V> submit(Runnable task, V result);

    Future<V> take() throws InterruptedException;

    Future<V> poll();

    Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;

CompletionService接口这几个方法都很常见了 不多说了 

public class ExecutorCompletionService<V> implements CompletionService<V> 

这个类实现了CompletionService接口 

    private final Executor executor;

这个Executor对象是执行任务的属性

    private final AbstractExecutorService aes;
这个是用来创建新异步任务的属性

    private final BlockingQueue<Future<V>> completionQueue;

这个是阻塞队列 代表已完成的任务

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

这个内部类是将任务添加进阻塞队列的类 封装了任务 

done方法将任务添加进阻塞队列 

    private RunnableFuture<V> newTaskFor(Callable<V> task) {
        if (aes == null)
            return new FutureTask<V>(task);
        else
            return aes.newTaskFor(task);
    }

    private RunnableFuture<V> newTaskFor(Runnable task, V result) {
        if (aes == null)
            return new FutureTask<V>(task, result);
        else
            return aes.newTaskFor(task, result);
    }

这俩是创建新任务的方法 都是判断AbstractExecutorService子类对象是否为空 为空就new出一个FutureTask来 不为空 就调用AbstractExecutorService 创建任务

    public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        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;
    }

构造方法 主要实例化三个属性 

其中第二个AbstractExecutorService类的属性是用instanceof判断参数Executor是不是AbstractExecutorService 是的话就赋引用 不是就将该属性置空 

第一个构造方法是new一个LinkedBlockingQueue 第二个是将参数队列赋给属性

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

这两个方法是将任务提交的方法

都是先判断任务为空 就抛出异常 

然后调用newTaskFor方法创建任务

调用executor来执行

最后返回执行完的任务

    public Future<V> take() throws InterruptedException {
        return completionQueue.take();
    }


    public Future<V> poll() {
        return completionQueue.poll();
    }


    public Future<V> poll(long timeout, TimeUnit unit)
            throws InterruptedException {
        return completionQueue.poll(timeout, unit);
    }

这几个方法都是调用阻塞队列的方法 take是阻塞当前线程 无参数poll是返回特殊值 有参数的poll是在指定时间里阻塞当前线程

这个ExecutorCompletionService介绍完毕