private final BlockingQueue<Runnable> workQueue;

private final HashSet<Worker> workers = new HashSet<Worker>();
// ---------------------------------------------------------------
// 曾经开启过的最大的线程数量
private int largestPoolSize;
// 完成的任务的数量
private long completedTaskCount;
// ---------------------------------------------------------------
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler handler;
private volatile long keepAliveTime;
private volatile boolean allowCoreThreadTimeOut;
private volatile int corePoolSize;
private volatile int maximumPoolSize;

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
    //注意，Runnable r 就是工作线程接口Worker，需要传到Thread中。
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group，r，
                               namePrefix + threadNumber.getAndIncrement()，
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
    /** Thread this worker is running in.  Null if factory fails. */
    //代表工作线程
    final Thread thread;
    /** Initial task to run.  Possibly null. */
    //该线程执行的第一个任务
    Runnable firstTask;
    /** Per-thread task counter */
    //该线程已经执行的任务数量
    volatile long completedTasks;
    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        //注意 将当前代理Runnable传递到ThreadFactory作为线程的执行载体。
        this.thread = getThreadFactory().newThread(this);
    }
    /** Delegates main run loop to outer runWorker  */
    //该Runnable作为代理，开启轮训，从队列中取出提交的Runnable来执行。
    public void run() {
        runWorker(this);
    }
    // Lock methods
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.
    //简单的互斥锁，把0修改为1代表获取到锁，把1修改为0代表释放锁。
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }
    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(); }
}

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 (;;) {
            //获取当前线程的数量，如果是核心线程模式，线程数量不能大于corePoolSize
            //如果是非核心线程模式，线程数量不能大于maximumPoolSize 否则返回false
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //使用cas 更新线程Worker的数量，更新成功退出循环
            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 {
        //创建Worker，Worker构造函数中会通过ThreadFactory创建Thread
        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();
                    //添加到 HashSet<Worker>集合中
                    workers.add(w);
                    //更新当前线程数量 给largestPoolSize赋值
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                //启动线程 开启任务轮训
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //如果线程启动失败 会将刚刚添加的Worker移除
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}
//Worker添加失败的处理
 private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //移除Worker 防止内存泄漏
            if (w != null)
                workers.remove(w);
            //减少Worker的数量
            decrementWorkerCount();
            //尝试终止线程池
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

 //Worker的run方法中调用runWorker方法开启轮训
public void run() {
            runWorker(this);       
 }
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        //首先执行firstTask 然后在通过getTask()方法从队列中取出任务执行。
        while (task != null || (task = getTask()) != null) {
            //执行任务前先加锁 可以通过tryLock方法 判断当前Worker线程是否在执行任务
            //如果在执行任务，tryLock返回false，否则，返回true
            w.lock();
            // If pool is stopping，ensure thread is interrupted;
            // if not，ensure thread is not interrupted.  This
            // requires a recheck in second case to deal with
            // shutdownNow race while clearing interrupt
            //如果线程池是处于STOP的状态，即调用了shutDownNow方法，确保线程是中断的
            if ((runStateAtLeast(ctl.get()，STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get()，STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                //hook方法，任务执行前调用beforeExecute，任务执行后调用afterExecute
                //可以通过这两个方法来监控线程池中任务的执行情况
                beforeExecute(wt，task);
                Throwable thrown = null;
                try {
                    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;
                //累加当前Worker已经完成的任务数量
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        //Worker退出时的后续处理
        processWorkerExit(w，completedAbruptly);
    }
}

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        //返回null的情况有两种
        //1.线程池的状态变为STOP。
        //2.线程池的状态是SHUTDOWN，当时队列是空的。
        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        int wc = workerCountOf(c);
        // Are workers subject to culling?
        //线程池并没有区分核心线程和非核心线程，只是根据当前的线程数量来使用不同的获取任务的方法
        //1.线程数量大于corePoolSize 或者设置了核心线程超时，则使用超时poll方法获取任务
        //2.线程数量等于corePoolSize并且没有设置核心线程超时，使用take方法获取任务
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            //超时，当前的Worker即将退出循环，因此，修改Worker的数量，然后返回null。
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime，TimeUnit.NANOSECONDS) :
                workQueue.take();
            //如果不是空的返回，如果是空的，说明已经超时，设置timeOut为true
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

private void processWorkerExit(Worker w，boolean completedAbruptly) {
    //completedAbruptly 代表线程是正常退出 还是异常退出
    //如果线程是正常退出，在getTask方法中已经调整了workerCount
    //如果线程异常退出，需要在这里调整workerCount
    if (completedAbruptly) // If abrupt，then workerCount wasn't adjusted
        decrementWorkerCount();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //把该Worker执行的任务数量累加到总任务数量变量中 然后从集合中移除Worker
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    //尝试终止线程池，只有最后一个Worker线程执行完，才会终止线程池
    tryTerminate();
    //获取线程状态，如果线程池的状态小于STOP 即RUNNING和SHUTDOWN状态，
    //并且线程是正常退出，计算当前应该存活的最小线程数量，如果min为0，但是队列不是空的，
    //则线程池还需要线程来执行任务，修改min为1
    //如果当前线程数量大于min，则直接返回，不需要补齐线程空缺
    //如果当前线程数量小于min，则调用addWorker补齐线程空缺。
    int c = ctl.get();
    if (runStateLessThan(c，STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null，false);
    }
}
 //尝试终止线程池
 final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
           //1.当前线程状态为RUNNING，直接返回，此时未调用shutDown或者shutDownNow方法，不需要终止。
           //2.当前线程状态大于TIDYING，说明其他Worker已经开始执行terminated()方法，为了保证该法仅            //  执行1次，直接返回。
           //3.当前线程状态为SHUTDOWN并且队列不是空的，直接返回，需要等待队列任务执行完再终止。
            if (isRunning(c) ||
                runStateAtLeast(c，TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            //如果worker数量不为0，尝试中断当前闲置的线程，即在poll和take中等待的线程，从而让所有线程
            //都退出任务轮训，加速线程池回收进程。
            if (workerCountOf(c) != 0) { // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                //更新线程池的状态为TIDYING，调用terminated()，这是一个hook方法，
                //可以在这里面做一些资源回收的操作，执行完后，设置线程池状态为TERMINATED
                //唤醒在awaitTermination方法上等待的线程。
                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
        }
    }
//尝试中断等待在取出任务的线程，如果onlyOnw为true，只会中断一个。
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();
        }
    }

ExecutorService executorService=Executors.newFixedThreadPool(5);
       // 1.创建线程池
        for(int i=0;i< 10;i++){
           executorService.execute(new Runnable(){
          @Override
          public void run(){
             System.out.println(Thread.currentThread().getName()+"办理业务");     
}
        });
    }
// 2.关闭线程池
        executorService.shutdown();
    // executorService.shutdownNow();
       }
    }

System.out.println(executorService.isShutdown());
System.out.println(executorService.isTerminated());
//关闭线程池
executorService.shutdown();
System.out.println(executorService.isShutdown());
System.out.println(executorService.isTerminated());

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING，0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;
// Packing and unpacking ctl
private static int runStateOf(int c)     { return c & ~CAPACITY; }
private static int workerCountOf(int c)  { return c & CAPACITY; }
private static int ctlOf(int rs，int wc) { return rs | wc; }