多线程（五）

invokeAll 说完以后，我们来看AbstractExecutorService的invokeAny方法，这个方法前面有代码说明过，与invokeAll不同的是，在给定的任务中，如果某一个任务完成（没有异常抛出），则返回任务执行的结果。这点从方法的返回值上面也能看出来。并不要求所有的任务全部的完成，只要一个完成（没有异常）即可。JDK的说明：

<T> T invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。

返回值为T 也说明了这一点。

源代码：

public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
        try {
            return doInvokeAny(tasks, false, 0);
        } catch (TimeoutException cannotHappen) {
            assert false;
            return null;
        }
    }

    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        return doInvokeAny(tasks, true, unit.toNanos(timeout));
    }

这个代码没有什么好说的，关键点地方在于doInvokeAny（）方法上面，直接上源码：

private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (tasks == null)
            throw new NullPointerException();
        int ntasks = tasks.size();
        if (ntasks == 0)
            throw new IllegalArgumentException();
        List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
        ExecutorCompletionService<T> ecs =
            new ExecutorCompletionService<T>(this);

        // For efficiency, especially in executors with limited
        // parallelism, check to see if previously submitted tasks are
        // done before submitting more of them. This interleaving
        // plus the exception mechanics account for messiness of main
        // loop.

        try {
            // Record exceptions so that if we fail to obtain any
            // result, we can throw the last exception we got.
            ExecutionException ee = null;
            long lastTime = timed ? System.nanoTime() : 0;
            Iterator<? extends Callable<T>> it = tasks.iterator();

            // Start one task for sure; the rest incrementally
            futures.add(ecs.submit(it.next()));
            --ntasks;
            int active = 1;

            for (;;) {
                Future<T> f = ecs.poll();
                if (f == null) {
                    if (ntasks > 0) {
                        --ntasks;
                        futures.add(ecs.submit(it.next()));
                        ++active;
                    }
                    else if (active == 0)
                        break;
                    else if (timed) {
                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                        if (f == null)
                            throw new TimeoutException();
                        long now = System.nanoTime();
                        nanos -= now - lastTime;
                        lastTime = now;
                    }
                    else
                        f = ecs.take();
                }
                if (f != null) {
                    --active;
                    try {
                        return f.get();
                    } catch (ExecutionException eex) {
                        ee = eex;
                    } catch (RuntimeException rex) {
                        ee = new ExecutionException(rex);
                    }
                }
            }

            if (ee == null)
                ee = new ExecutionException();
            throw ee;

        } finally {
            for (Future<T> f : futures)
                f.cancel(true);
        }
    }

这个比较的复杂，还是一步步的来：

首先是根据任务建立返回值。

List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);

ntasks 为当前任务数。

然后是建立ExecutorCompletionService JDK对这个类的说明是：

使用提供的 Executor 来执行任务的 CompletionService。此类将安排那些完成时提交的任务，把它们放置在可使用 take 访问的队列上。该类非常轻便，适合于在执行几组任务时临时使用。具体的源代码，我们会在后面加以分析。

具体的实现的代码在try/catch中

ntasks 当前的任务数

active 当前运行的进程数

// Start one task for sure; the rest incrementally

futures.add(ecs.submit(it.next()));

首先提交一个task，然后进入循环，这样能够提交效率。

然后进入无限循环，被分为了两种情况：

if (f == null)

我们还有首先说一下ecs.poll 的方法的作用：检索并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null。

如果f == null 说明此事没有任务完成，分为三种情况：

（1） 当前进程还没有提交完，则继续提交进程（越到后面越慢，所以在提交任务的时候一般把执行时间较短的任务放在前面，即是从到小的排列顺序，能够提交效率）

（2） 如果当前执行的进程数为0，直接的跳出循环，这个是一个异常的分支，跳出循环以后，执行的是：if (ee == null) ee = new ExecutionException(); throw ee; 抛出异常。

（3） 如果已经没有可以提交的任务，并且还有任务在执行，也就是（1）/(2) 不成立，立即去获取任务的结果，如果有时间限制，则是f = ecs.poll(nanos, TimeUnit.NANOSECONDS);，获取不到则抛出超时异常 。没有则是f.get();

这里针对条件（3）进行说明，如果没有可以提交的任务，并且当前还有任务只在执行的情况下才会执行到（3），这个也是为了能够更加的快速的获取结果，尽快的获得任务重最先完成的哪一个任务。这样能够阻塞的获取任务的结果。

If（f ！= null）

f 不为null 说明已经有任务完成了，减少正在执行的任务数，直接取得执行结果（可能会阻塞）。

最后在finally中，取消所有的任务。

InvokeAll的主要的逻辑已经分析完毕，我们还遗留一个小尾巴，他怎么保证任务执行完以后直接的塞到结果的序列中，这个比较的重要，就是Poll方法。

首先我们来看一下但是调用的构建函数源码：

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

从构建的函数来看这个executor就是abstractExecutorService。我们使用的方法主要是：

ecs.submit(it.next())

ecs.poll();

ecs.poll(nanos, TimeUnit.NANOSECONDS);

可以看到这些方法的主要的关键在于结果队列completionQueue，无论是take，还是poll 都是BlockingQueue支持的，从源代码中方法 poll（）以及 take（）能够看到。源代码上面是：

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

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

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

那就还剩下一个主要的问题：完成的任务是怎么放到这个队列中的？那么我们首先还是需要关注提交任务的方法：

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

QueueingFuture 为内部类，源码为：

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

看到这个方法的重定义：protected void done() { completionQueue.add(task); }

关于接口done（）的方法JDK说明：

protected void done()

当此任务转换到状态 isDone（不管是正常地还是通过取消）时，调用受保护的方法。默认实现不执行任何操作。子类可以重写此方法，以调用完成回调或执行簿记。注意，可以查询此方法的实现内的状态，从而确定是否已取消了此任务。

子类QueueingFuture 重写done（）方法， 当task完成的，会把执行的结果放到completionQueue中。实现前面所说的当任务完成时，放到了完成的阻塞队列中。

因为这个原因，在JDK中关于ExecutorCompletionService有两种应用的情况：

假定您有针对某个问题的一组求解程序，每个求解程序都能返回某种类型的 Result 值，并且您想同时运行它们，使用方法 use(Result r) 处理返回非 null 值的每个求解程序的返回结果。可以这样编写程序：

void solve(Executor e, Collection<Callable<Result>> solvers)

    throws InterruptedException, ExecutionException {

        CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);

        for (Callable<Result> s : solvers)

            ecs.submit(s);

        int n = solvers.size();

        for (int i = 0; i < n; ++i) {

            Result r = ecs.take().get();

            if (r != null)

                use(r);

        }

假定您想使用任务集中的第一个非 null 结果，而忽略任何遇到异常的任务，并且在第一个任务就绪时取消其他所有任务：

void solve(Executor e, Collection<Callable<Result>> solvers) 
      throws InterruptedException {
        CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
        int n = solvers.size();
        List<Future<Result>> futures = new ArrayList<Future<Result>>(n);
        Result result = null;
        try {
            for (Callable<Result> s : solvers)
                futures.add(ecs.submit(s));
            for (int i = 0; i < n; ++i) {
                try {
                    Result r = ecs.take().get();
                    if (r != null) {
                        result = r;
                        break;
                    }
                } catch(ExecutionException ignore) {}
            }
        }
        finally {
            for (Future<Result> f : futures)
                f.cancel(true);
        }

        if (result != null)
            use(result);
    }

在JDK说明的第二种情况和invokeAny比较的像，可以进行类比。