1、构造方法

public ThreadPoolExecutor(int corePoolSize,                     //核心线程数
                          int maximumPoolSize,                  //线程池最大容量
                          long keepAliveTime,                   //线程保活时间，实现方式是：延时从任务队列取任务。
                          TimeUnit unit,                        //保活时间单位
                          BlockingQueue<Runnable> workQueue,    //任务队列
                          ThreadFactory threadFactory)          //创建线程工厂

BlockingQueue<Runnable> workQueue;          //任务队列。如果当前没有空闲线程，任务会存储到此队列。队列由用户创建，通过构造方法传进来。
HashSet<Worker> workers = new HashSet<>();  //工作的线程Set，工作线程和空闲线程都存储在这里。

2、 public void execute(Runnable command)方法发送任务给线程池。

• 如果当前线程数没有达到最大核心线程数，会创建核心线程。
• 否则会把任务添加进任务队列，然后再创建非核心线程。
• （创建线程方法addWorker(Runnable firstTask, boolean core)，core是线程种类，核心/非核心。是否达到最大线程数，是在创建过程中判断的。）

3、 addWorker(Runnable firstTask, boolean core)

一、 addWorker创建一个工作线程是通过创建一个包含一个Thread的Worker类。
二、 Worker本身继承了Runnable接口，包含run()方法。把自己传入自己包含的Thread变量中执行。
三、 addWorker中有调用了worker.thread.start(), 就在新的线程中执行了其包含的Runnable(worker),调用了worker的run()方法，中的runWorker()，方法。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable {
    ...
     Worker(Runnable firstTask) {
                setState(-1); // inhibit interrupts until runWorker
                this.firstTask = firstTask;
                this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
        runWorker(this);
    }
    ...
}

4、 runWorker(Worker w)方法已经在新的线程中运行。

新线程中通过while循环执行task，Worker中的task不为空就执行，如果Worker中的task为空，就通过getTask()方法取任务队列中的任务。

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    try {
        while (task != null || (task = getTask()) != null) {
        ...
        }

5、 Runnable getTask()获取任务队列中的任务。

线程保活时间也是从这里完成的。延时的从任务队列中取任务，如果延时后取出为null，线程结束。如果取出了，就继续在当前线程中执行Runnable任务。也完成了，线程池的复用和任务队列的顺序执行。

private Runnable getTask() {

    for (;;) {

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;