ThreadPoolExecutor源码解析

    一、新建线程池的是构造方法

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

各参数解析
corePoolSize – 核心线程数 要保留在池中的线​​程数，即使它们处于空闲状态，除非设置了 allowCoreThreadTimeOut

     当核心线程数被设置为true后，调用interruptIdleWorkers中断空闲线程的方法、
    public void allowCoreThreadTimeOut(boolean value) {
        if (value && keepAliveTime <= 0)
            throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
        if (value != allowCoreThreadTimeOut) {
            allowCoreThreadTimeOut = value;
            if (value)
                interruptIdleWorkers();
        }
    }


    1、 获取当前锁对象并锁住该方法
    2、遍历循环工作线程 判断每个线程如果没有中断，并获取当前线程尝试获取锁成功，代表该线程是空闲线程 那么中断这个线程。
    3、当只有一个线程的时候，不做处理 线程池中始终会保持一个线程
 private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

maximumPoolSize – 最大线程数 池中允许的最大线程数
keepAliveTime – 当线程数大于核心数时，这是多余空闲线程在终止前等待新任务的最长时间。如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。
unit – keepAliveTime 参数的时间单位
workQueue – 底层使用BlockingQueue阻塞队列 用于在执行任务之前保存任务的队列。这个队列将只保存 execute 方法提交的 Runnable 任务。

ThreadFactory：创建线程工厂，可以自定义线程工厂给线程池里的线程设置一个自定义线程名。

     DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

handler：饱和策略，假如线程池已满，并且没有空闲的线程，这个时候不再允许提交任务到线程池，线程池提供了4中策略，至于具体采用哪种策略还是自定义策略，具体情况具体分析。
AbortPolicy：拒绝提交，直接抛出异常，也是默认的饱和策略；
CallerRunsPolicy：线程池还未关闭时，用调用者的线程执行任务；
DiscardPolicy：丢掉提交任务；
DiscardOldestPolicy：线程池还未关闭时，丢掉阻塞队列最久为处理的任务，并且执行当前任务。

如果以下条件之一成立：corePoolSize < 0 keepAliveTime < 0 maximumPoolSize <= 0 maximumPoolSize < corePoolSize

抛出：
IllegalArgumentException 

二、看execute方法

如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；

如果队列已经满了，则在总线程数不大于maximumPoolSize的前提下，则创建新的线程

如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
   1.主池控制状态ctl是一个原子整数，
 封装了两个概念字段workerCount，表示有效线程数runState，
表示是否正在运行、正在关闭等为了打包成一个int，
我们限制workerCount为(2^29 )-1（约 5 亿）个线程 --即最多可工作的线程最多为5亿多个
而不是 (2^31)-1（20 亿）个其他可表示的线程。
   2、
        线程池用ctl的低29位表示线程池中的线程数，高3位表示当前线程状态，后续假如想要增大这个值，可以将AtomicInteger改成AtomicLong。

     runState 提供主要的生命周期控制，取值： 111
     RUNNING：接受新任务并处理排队任务   000 
     SHUTDOWN：不接受新任务，但处理排队任务  001
     STOP：不接受新任务，不处理排队任务，并中断正在进行的任务  010
     TIDYING：所有任务都已终止  011
        int c = ctl.get();
        //当工作线程数小于核心线程数时 直接创建新的线程池
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        检测线程池是否还在运行 并且将任务存放到缓存队列中
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            重新检测线程池是否还在运行 如果没有运行 remove任务 并拒绝任务
            if (! isRunning(recheck) && remove(command))
                reject(command);
            
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        如果 添加缓存队列失败 那么新建线程数，
        如果线程数量大于最大线程数量，那么将使用拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }




检查是否可以根据当前池状态和给定界限（核心或最大值）添加新的工作线程。
如果是这样，则相应地调整工作人员数量，并且如果可能，将创建并启动一个新工作人员，
将 firstTask 作为其第一个任务运行。如果池已停止或有资格关闭，
则此方法返回 false。如果线程工厂在询问时未能创建线程，它也会返回 false。
如果线程创建失败，无论是由于线程工厂返回 null，还是由于异常
（通常是 Thread.start() 中的 OutOfMemoryError），我们都会干净利落地回滚。
参数：
firstTask – 新线程应该首先运行的任务（如果没有，则为 null）。
当线程少于 corePoolSize 时（在这种情况下我们总是启动一个），
或者当队列已满（在这种情况下我们必须绕过队列）时，
使用初始的第一个任务（在方法 execute() 中）
创建工作线程以绕过队列.最初空闲线程通常通过 prestartCoreThread 创建或替换其他垂死的工人。
core – 如果为 true，则使用 corePoolSize 作为绑定，
否则为 maximumPoolSize。 （此处使用布尔指标而不是值以确保在检查其他池状态后读取新值）。
返回：
如果成功则为真
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            
            int c = ctl.get();
            //获取正在运行状态的线程数
            int rs = runStateOf(c);

            检查 SHUTDOWN  =0 
            rs是否大于0 或者 运行线程是否为空 工作队列是否为空
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                查看线程池中线程的数量
                int wc = workerCountOf(c);
                 线程池中的数量是否大于容量或者wc是否大于核心线程数 返回失败
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                 利用cas去添加线程池中的数量 如果成功结束流程  跳出循环
                 如果失败重新获取C值
                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;
    }