线程池原理（面试）

1. 什么是线程池？

    顾名思义，存放线程的一个池子。

2.怎么设计一个线程池

    (1) 新建一个数组，创建一堆线程存放进去；

    (2) 线程池中的线程来处理任务，处理完成后回收线程而不是销毁线程；

    (3) 设计等待队列来存放来不及处理的任务；

    (4) 拒绝策略

4.JDK中的线程池

4.1 线程池的参数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

 corePoolSize：线程池核心线程数量。线程池创建之后不会立即去创建线程，而是等待线程的到来。当当前执行的线程数大于改值是，线程会加入到缓冲队列；
maximumPoolSize：线程池中创建的最大线程数；
keepAliveTime：空闲的线程多久时间后被销毁。默认情况下，改值在线程数大于corePoolSize时，对超出corePoolSize值得这些线程起作用。
unit：TimeUnit枚举类型的值，代表keepAliveTime时间单位，可以取下列值：
       TimeUnit.DAYS; //天
　　TimeUnit.HOURS; //小时
　　TimeUnit.MINUTES; //分钟
　　TimeUnit.SECONDS; //秒
　　TimeUnit.MILLISECONDS; //毫秒
　　TimeUnit.MICROSECONDS; //微妙
　　TimeUnit.NANOSECONDS; //纳秒
workQueue：阻塞队列，用来存储等待执行的任务，决定了线程池的排队策略，有以下取值：
　　ArrayBlockingQueue;
　　LinkedBlockingQueue;
　　SynchronousQueue;
threadFactory：线程工厂，是用来创建线程的。默认new Executors.DefaultThreadFactory();
handler:线程拒绝策略。当创建的线程超出maximumPoolSize，且缓冲队列已满时，新任务会拒绝，有以下取值：
　　ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

4.2 线程池工作流程

      第一阶段：线程池创建时并不会马上创建一堆线程，而是按需创建；

      第二阶段：请求抵达且核心线程数够用且没有空闲线程，那么创建新线程并分配任务；

      第二阶段：核心线程数不够用了，将任务放到阻塞队列；

      第三阶段：阻塞队列满了，那么额外创建新线程直到达到最大线程数；

      第四阶段：最大线程数也不够用了，那么拒绝策略开始发挥作用。

4.3 创建默认线程池

    ExecutorService pool = null；
    pool =  Executors.newSingleThreadExecutor();  //单线程线程池
    pool =  Executors.newFixedThreadPool(3); //固定线程线程池
    pool =  Executors.newCachedThreadPool();// 可变大小线程池
    pool =  Executors.newScheduledThreadPool(3); 定时任务线程池

此处用到了设计模式中的建造者模式。其中Executors是建造者，ExecutorService代表被创建的抽象级线程池，最后创建出来的线程池才是真正的实现。

5. 深入源码了解线程池的原理

以下，我们已固定线程线程池的创建为例深入了解线程池的工作原理。一切的故事，都源自于下面这行代码：

ExecutorService pool = Executors.newFixedThreadPool(3); //固定线程线程池

我们点进去看看它是怎么实现的：

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

 可以看到，在固定线程线程池的创建过程中，最大线程数和核心线程数是同一个数值。另外，此处创建了一个ThreadPoolExecutor对象，我们跟进去看看：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        //让当前线程获取系统权限
        this.acc = System.getSecurityManager() == null ? null : AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

上面的两个方法是依次调用的关系，核心在第二个方法里。发现构造方法都走完了，也没发现线程创建的迹象，印证了上面的描述，第一阶段线程池创建时并不会马上创建一堆线程。接下来，我们哟那个下面这行代码作为锲子调用一下线程池：

pool.execute(new Thread());

我们进入execute()方法：

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

它是Executor借口直接提供的。所以我们需要关注一下都有哪些实现类：

通过这个图，我们可以看到父子关系了。Excutor接口被ExecutorService接口继承，然后被AbstractExecutorService类实现，最后又被ThreadPoolExecutor类重写。好的，那我们看看ThreadPoolExecutor类中它是怎么设计的：

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        // 获取线程池控制状态
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // worker数量小于corePoolSize
            if (addWorker(command, true)) // 添加worker
                // 成功则返回
                return;
            // 不成功则再次获取线程池控制状态
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { // 线程池处于RUNNING状态，将命令（用户自定义的Runnable对象）添加进workQueue队列
            // 再次检查，获取线程池控制状态
            int recheck = ctl.get();
            if (!isRunning(recheck) && remove(command)) // 线程池不处于RUNNING状态，将命令从workQueue队列中移除
                // 拒绝执行命令
                reject(command);
            else if (workerCountOf(recheck) == 0) // worker数量等于0
                // 添加worker
                addWorker(null, false);
        }
        else if (!addWorker(command, false)) // 添加worker失败
            // 拒绝执行命令
            reject(command);
    }

上面代码中的英文注释很好的对应了之前的第二、第三、第四、第五阶段，此处不再赘述。下面放上addWorker()方法的代码：

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

 此外，拒绝策略的处理也需要关注下：

    final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
    }

此处的handler就是RejectedExecutionHandler 参数，它的实现有四种：

我们随便取一种看下：

    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

可以看到，它会确认一下线程池是否关闭了，如果没有，就替线程池把任务处理了（自己执行了）。

 

还需要注意的点是，单线程线程池和定时任务线程池是特例。首先是单线程线程池，我们看看它的实现：

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

可以看到，它只创建了一个线程，而且它返回的并不是原始的ThreadPoolExecutor。下面是FinalizableDelegatedExecutorService的实现：

     static class DelegatedExecutorService extends AbstractExecutorService {
        private final ExecutorService e;
        DelegatedExecutorService(ExecutorService executor) { e = executor; }
        public void execute(Runnable command) { e.execute(command); }
        public void shutdown() { e.shutdown(); }
        public List<Runnable> shutdownNow() { return e.shutdownNow(); }
        public boolean isShutdown() { return e.isShutdown(); }
        public boolean isTerminated() { return e.isTerminated(); }
        public boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.awaitTermination(timeout, unit);
        }
        public Future<?> submit(Runnable task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Callable<T> task) {
            return e.submit(task);
        }
        public <T> Future<T> submit(Runnable task, T result) {
            return e.submit(task, result);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException {
            return e.invokeAll(tasks);
        }
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                             long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.invokeAll(tasks, timeout, unit);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException {
            return e.invokeAny(tasks);
        }
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                               long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return e.invokeAny(tasks, timeout, unit);
        }
    }

   static class FinalizableDelegatedExecutorService
        extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
        protected void finalize() {
            super.shutdown();
        }
    }

此处的实现用到了代理模式，而且在FinalizableDelegatedExecutorService中增加了finalize方法保证可回收。

至于定时任务线程池，我们同样看看它的实现：

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

发现它实例化的不是ThreadPoolExecutor了，而是ScheduledExecutorService。我们把上面一张图再拿出来看看

果然，在源码里也找到了答案：

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {
}

那么，我们再来看看ScheduledExecutorService的构造方法

 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

既然又丢给了ThreadPoolExecutor，那构造方法就看不出什么了。那么，所有的答案一定都在execute()方法里了：

    public void execute(Runnable command) {
        schedule(command, 0, NANOSECONDS);
    }

    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit)));
        delayedExecute(t);
        return t;
    }
    
    private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }