addWorker()方法

//校验是否满足增加的条件


//1.firstTask：用于指定新增的线程执行的【第一个任务】，firstTask==null时，代表仅增加执行线程。
//2.core:（ture）添加线程时与corePoolSize比较，否则与maximumPoolSize比较
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        //获取当前线程运行状态
        int c = ctl.get();
        int rs = runStateOf(c);

    /*
     * 如果rs >= SHUTDOWN（0），则表示此时不再接收新任务；
     * 接着判断以下3个条件，只要有1个不满足，则返回false：
     * 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务
     * 2. firsTask为空
     * 3. 阻塞队列不为空
     * 
     * 首先考虑rs == SHUTDOWN的情况
     * 这种情况下不接受新提交的任务，所以在firstTask不为空的时候会返回false；
     * 然后，如果firstTask为空，并且workQueue也为空，则返回false；即：如果队列中已经没有任务了，不需要再添加线程
     *
     * 但是如果队列不会空，则可以继续执行
     */

        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;
            // 尝试增加workerCount，如果成功，则跳出第一个for循环（为什么修改c值？因为满足增加线程的条件，而变量c记录线程池中线程的数量）
            //cas修改数据可能失败，如果失败，则继续执行内循环
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl

            // 如果当前的运行状态不等于rs，说明状态已被改变，返回外层for循环，继续执行外层for循环校验
            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 {
        //firstTask作为入参，创建Worker对象
        w = new Worker(firstTask);
        //每一个Worker对象都会创建一个线程
        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());

                // rs < SHUTDOWN表示是RUNNING状态；
                // rs是RUNNING状态 || rs是SHUTDOWN状态 && firstTask为null，向线程池中添加线程。
                // 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // 测试线程是否是活跃状态（即：调用了start方法，则为true）
                        throw new IllegalThreadStateException();
                    //使用set集合暂存worker对象
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize记录当前线程池中最大线程数
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                //启动worker相关线程，通过run方法调用runWork方法
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

//Worker类继承AQS、实现Runnable接口  
private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /** 具体执行任务的线程. */
        final Thread thread;
        
        /** 初始的待任务，可能为空 */
        Runnable firstTask;
        
        /** 记录每个线程完成任务数 */
        volatile long completedTasks;

        /**
         *构造函数中，利用ThreadFactory产生新的线程，并给新线程第一个任务（任务可能为null）
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            setState(-1); // 在运行worker前，禁止线程中断操作。（如果想对worker操作，必须获取锁，将state=0，改成state=1，设置为1，则无法获取锁）
            this.firstTask = firstTask;
            //创建新线程，并给新线程初始化执行逻辑（worker就是Runnable，在run方法中定义了处理逻辑）
            this.thread = getThreadFactory().newThread(this);
        }

        /** runWorker为主要处理逻辑  */
        public void run() {
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
        //尝试获取锁（cas方式0-->1）
        //tryAcquire方法判断state是否为0，所以setState(-1);将state设置为-1，为了禁止在执行任务前（调用runWorker前）对线程进行中断。
        //在runWorker方法中会先调用Worker对象的unlock方法将state设置为0。（当state=0时，worker线程可以被中断）
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }
        
        //中断当前线程
        //isInterrupted()：判断线程对象中是否设置了中断标识，如果设置，则返回true，但不会清除中断标识，再次调用仍为true。
        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    //没有设置中断，则执行中断操作
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

//每个线程都会循环获取队列中的任务，并调用任务的run()方法
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    //获取第一个任务,可能为空
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // （将state从-1修改为0，允许中断操作）
    //是否因为异常退出循环
    boolean completedAbruptly = true;
    try {
        //如果task=null，则获取队列中任务，即：队列任务最后执行
        while (task != null || (task = getTask()) != null) {
            w.lock();
            //如果线程池正在停止，那么要保证当前线程是中断状态；
            //如果不是的话，则要保证当前线程不是中断状态；
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();//中断当前线程
            try {
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //当前线程调用传入线程池任务的run方法
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

STOP
        //001
        //状态切换：调用线程池的shutdownNow()方法。（RUNNING、SHUTDOWN-->STOP）
        //状态说明：不再接受新任务，不再处理队列中的任务，并且中断当前执行的任务。
        private static final int STOP       =  1 << COUNT_BITS;

private Runnable getTask() {
    //上次从阻塞队列中（使用poll方法）获取任务，是否超时。
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

    /*
     * 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断：
     * 1. rs >= STOP，线程池是否正在stop；
     * 2. 阻塞队列是否为空。
     * 如果以上条件满足，则将workerCount减1并返回null。【返回null，调用getTask处，会跳出循环，并对线程销毁处理】
     * 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务。
     */
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();//使用CAS方式操作，将Worker数量减1
            //返回null，终止runWork方法中循环
            return null;
        }

        //wc：线程池中线程数
        int wc = workerCountOf(c);

        // timed：判断是否需要进行超时控制。
        // allowCoreThreadTimeOut默认是false，即：核心线程不进行超时回收；
        // wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
        // 对于超过核心线程数量的这些线程，需要进行超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

    /*
     * wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
     * timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
     * 如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
     * 如果减1失败，执行continue，进行重试。
     * 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
     */
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        /*
         * 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控制，如果在keepAliveTime时间内没有获取到任务，则返回null；
         * 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。【保证核心线程，不会被销毁的方式】。
         * keepAliveTime：线程池初始化时，设置的参数
         */
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            // 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
            timedOut = false;
        }
    }
}

private void processWorkerExit(Worker w, boolean completedAbruptly) {

    // 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
    // 如果线程执行时没有出现异常，说明在getTask()方法中已经完成对workerCount进行了减1操作。
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();


    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //统计完成的任务数
        completedTaskCount += w.completedTasks;
        //从线程池中移除工作线程
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }

    // 对线程池进行判断，尝试设置线程池为最终态
    //如果（SHUTDOWN且线程池和队列为空）或（STOP且线程池为空），则转换为终止状态（TERMINATED）。
    tryTerminate();


    int c = ctl.get();

/*
* 保留线程池中线程操作
* 当线程池是RUNNING或SHUTDOWN状态时（c<STOP），如果worker是异常结束，直接通过addWorker方式想线程池添加线程；
* 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；
* 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
*/
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {//正常结束。completedAbruptly=false
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

如果（SHUTDOWN且线程池和队列为空）或（STOP且线程池为空），则转换为终止状态（TERMINATED）。
如果有资格终止，但workerCount不为零，则中断空闲工作进程，以确保停机信号传播。
必须在可能导致终止的任何操作之后调用此方法，这些操作包括减少worker计数或在关机期间从队列中删除任务。

该方法是非私有的，允许从ScheduledThreadPoolExecutor进行访问    
final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            
            //校验是否进行终止线程池操作
            //1.线程池为RUNNING状态。（不能终止）
            //2.线程池为TERMINATED状态（已经终止）。
            //3.线程池为SHUTDOWN状态且队列不为null（不能终止，需要处理完队列任务）
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            
            //符合终止条件。判断线程池中是否还存在线程，如果存在，则设置中断标识（调用interrupt方法）
            if (workerCountOf(c) != 0) { // Eligible to terminate
                //中断线程池中线程
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            
            //设置线程池终止状态
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                       //设置线程池状态为终态。
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }