多线程（四）

承接上面 上面的submit方法，与之相关联的有两个方法invokeAll 和invokeAny 的源码，我们来看一下这两个方法：

首先是invokeAll的简单的，没有时间限制的方法，JDK说明,源码如下:

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
          执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
        if (tasks == null)
            throw new NullPointerException();
        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<T> t : tasks) {
                RunnableFuture<T> f = newTaskFor(t);
                futures.add(f);
                execute(f);
            }
            for (Future<T> f : futures) {
                if (!f.isDone()) {
                    try {
                        f.get();
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }

1. 首先根据传入的tasks，构建返回任务的数据：

List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());

2. 根据任务，封装为FutureTask，这样就能够记录任务的状态：

3.执行任务，这个任务执行在子类ThreadPoolExecutor的实现，这个会在以后说明，直接的理解为执行了。

上面的一个for循环，就是构建数据，然后执行，没有阻塞的概念。

下面的这个for循环，就有阻塞的概念，4.f.get();  取任务的执行的结果，这个就是一个会阻塞主线程的地方，因为如果任务没有完成，这个是必然会阻塞，知道任务完成（完成，取消，或者异常）。

try/catch后面的finally语句，表示的是：

判断任务是否done，如果没有(这种情况一般只有当任务为null才会发生)，则必须把所有任务都cancel掉，底层会中断所有线程，回收资源。

测试的代码，使用多线程（二）里面的CallabelTask

public static void invokeAllCallableTask()throws Exception{
        ExecutorService executor = Executors.newCachedThreadPool();
        List<CallabelTask> tasks = new ArrayList<CallabelTask>(5);
        for(int i = 0; i < 5; ){
            tasks.add(new CallabelTask("task_"+(++i)));
        }
        List<Future<String>> results = executor.invokeAll(tasks);
        System.out.println("All the tasks have been submited through invokeAll method!");
        executor.shutdownNow();
        for(Future<String> f : results)
            System.out.println(f.get());
    }

 

这段代码会在executor.invokeAll(tasks)行阻塞当前线程，直到所有任务都执行完(完成 or 取消 or异常)，才会继续往下执行println语句进行打印。这里可以调用executor.shutdownNow()立马关闭线程执行器而不会有问题，因为在执行这一句的时候所有任务肯定已经执行完了。而在“AbstractExecutorService任务提交<一>”submit方法测试中，若使用shutdownNow()会有异常，因为它会去cancel正在执行的任务，很容易直到这个异常便是线程的中断异常了。

关于第二个invokeAll重载方法，逻辑和第一个invokeAll方法是一样的，不同的是这个方法加了时间的限制：

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
        if (tasks == null || unit == null)
            throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<T> t : tasks)
                futures.add(newTaskFor(t));

            long lastTime = System.nanoTime();

            // Interleave time checks and calls to execute in case
            // executor doesn't have any/much parallelism.
            Iterator<Future<T>> it = futures.iterator();
            while (it.hasNext()) {
                execute((Runnable)(it.next()));
                long now = System.nanoTime();
                nanos -= now - lastTime;
                lastTime = now;
                if (nanos <= 0)
                    return futures;
            }

            for (Future<T> f : futures) {
                if (!f.isDone()) {
                    if (nanos <= 0)
                        return futures;
                    try {
                        f.get(nanos, TimeUnit.NANOSECONDS);
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    } catch (TimeoutException toe) {
                        return futures;
                    }
                    long now = System.nanoTime();
                    nanos -= now - lastTime;
                    lastTime = now;
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }

时间限制主要有两部分：

第一个循环，是依此提交任务阶段，有时间限制。假如有１０个任务要提交，那么循环提交的时每次都会检查是否超时，如果提交到第８个发现超时了，那么第９、１０两个任务就不会在调用execute了，而是直接返回这批任务；

在第二个循环中，这时依此取执行结果阶段，每次也会判断是否超时，一旦发现超时就立马返回这批任务。

当然如果超时返回，将无法执行后续语句done = true; 这样在finally中就会把所有任务都cancel掉。而客户端(主线程)就会收到CancellationException。