线程池源码学习（一）

都知道，线程池主要是对线程的管理，也便于我们去进行使用，面试也是经常性的提到，但是在我实习的过程中，却很少看到有使用的地方。

其实线程池的链路挺长的，父级的接口就有两个。

一级一级看吧，先看Executor，这个接口只有一个定义，也是最重要的一部分

我们的所有线程都是通过这个execute()方法进行执行的。

在来看下Executor的一个“服务类”，有点像“装饰器模式”，只是我觉得像 ，这里面涉及到的方法就有很多了，比如我们最常见的submit、shutdown等等。

ps: 以下均基于AbstractExecutorService查看

1.submit ( )

先来看submit()这个方法吧，他的实现在抽象类的AbstractExecutorService类中，其实在我的理解下，submit方法主要就是单个线程每一次手动的提交

我们会发现这里面他主要涉及到了newTaskFor()这个方法，在new
newTaskFor(Runnable)这里有一点点的区别，这里面使用到了适配器的设计，针对Runnable生成的线程，将Runnable线程使用RunnableAdapter进行包装并实现Callable，内部实现call()方法，我们都知道，线程的创建中，Thread和Runnable都是重写run()方法的，Callable是重写call()方法，所以在RunnableAdapter中内部实现call()的时候，将run()方法写在其中，则完成了包装/适配。

2.invokeAll ( )

invokeAll()这个方法其实很好理解。

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
        // 日常判空
        if (tasks == null)
            throw new NullPointerException();
        // 将超时时间换算成毫秒
        long nanos = unit.toNanos(timeout);
        // 每个线程都需要一个自己的未来数据结果集、状态，用于获取状态啥的
        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
        // 记录下面的代码块是否全部正常执行完成
        boolean done = false;
        try {
            // 针对线程做前置准备，不计入耗时中
            for (Callable<T> t : tasks)
                futures.add(newTaskFor(t));
            // 计算超时的时间点
            final long deadline = System.nanoTime() + nanos;
            final int size = futures.size();
            // 针对每个线程进行异步执行，并且每异步一个线程，计算一下耗时，超时则直接结束
            for (int i = 0; i < size; i++) {
                // 执行对应线程
                execute((Runnable)futures.get(i));
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L)
                    return futures;
            }
            // 循环每一个线程，超时直接结束
            for (int i = 0; i < size; i++) {
                Future<T> f = futures.get(i);
                if (!f.isDone()) {
                    if (nanos <= 0L)
                        return futures;
                    try {
                        // 直接阻塞，如果发生非超时异常nanos刷新
                        f.get(nanos, TimeUnit.NANOSECONDS);
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    } catch (TimeoutException toe) {
                        return futures;
                    }
                    nanos = deadline - System.nanoTime();
                }
            }
            // 所有线程正常执行完成
            done = true;
            return futures;
        } finally {
            // 当执行过程中，有没有正常执行完成的线程，那么就将所有线程重新停止一遍
            if (!done)
                for (int i = 0, size = futures.size(); i < size; i++)
                    futures.get(i).cancel(true);
        }
    }

其实在看上面的代码时候，我想过一个疑惑，为什么单独的对TimeoutException 异常进行了处理，直到看到f.get(nanos, TimeUnit.NANOSECONDS);里面的代码才发现他阻塞了这个线程，并且阻塞到超时状态，继而抛出异常。

3.invokeAny ( ) \ doInvokeAny ( )

这两个方法基本就是差不多吧，比较有意思的是invokeAny(Collection<? extends Callable> tasks)这个方法，会发现他没有设置超时时长，但是都是走的 doInvokeAny(Collection<? extends Callable> tasks, boolean timed, long nanos)这个方法，所以invokeAny(Collection<? extends Callable> tasks)在TimeoutException异常拦截增加了一个断言（assert），毕竟没有超时，那么这个异常固然不存在了。

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();
        // 每个线程都需要一个自己的未来数据结果集、状态，用于获取状态啥的
        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
        //以当前实例对象作为参数构建ExecutorCompletionService对象
        // ExecutorCompletionService负责执行任务，后面调用用poll返回第一个执行结果
        ExecutorCompletionService<T> ecs =
            new ExecutorCompletionService<T>(this);
        try {
            // 记录可能抛出的执行异常
            ExecutionException ee = null;
            // 初始化超时时间 兼容没有设置超时的方法
            final long deadline = timed ? System.nanoTime() + nanos : 0L;
            Iterator<? extends Callable<T>> it = tasks.iterator();
            //提交任务，并将未来返回的结果数据添加到future中
            //提交一个任务主要是确保在进入循环之前开始一个任务
            futures.add(ecs.submit(it.next()));
            // 减少一个可执行任务的数量
            --ntasks;
            // 记录当前正在执行的任务数量
            int active = 1;
            for (;;) {
                //从完成任务的BlockingQueue队列中获取并移除下一个将要完成的任务的结果。
                //如果BlockingQueue队列中中的数据为空，则返回null
                //这里的poll()方法是非阻塞方法
                Future<T> f = ecs.poll();
                if (f == null) {
                    // 没有一个任务执行完成，那么就将还没有执行的任务执行
                    if (ntasks > 0) {
                        //未执行的任务数量减1
                        --ntasks;
                        futures.add(ecs.submit(it.next()));
                        ++active;
                    }
                    else if (active == 0)
                        break;
                    //如果timed为true，则执行获取结果数据时设置超时时间，也就是超时获取结果表示，这里的poll()方法是阻塞方法
                    else if (timed) {
                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                        if (f == null)
                            throw new TimeoutException();
                        nanos = deadline - System.nanoTime();
                    }
                    // （前提是没设置超时）当把所有任务提交之后仍没有任何任务有结果，则无限制的等待，直到有一个任务有结果
                    else
                        f = ecs.take();
                }
                // 如果有任务执行完成的结果
                if (f != null) {
                    // 对正在执行任务数减1
                    --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 (int i = 0, size = futures.size(); i < size; i++)
                futures.get(i).cancel(true);
        }
    }