首页 > 代码库 > 多线程(五)

多线程(五)

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比较的像,可以进行类比。

多线程(五)