public class ThreadPoolExecutor extends AbstractExecutorService {
        /** 我以一个字节8位来简化解释线程池对运行状态和当前有效线程个数的原子管理方案
    
         * 线程池当中，用一个ctl原子变量包装了高3位的运行状态和低5位的线程个数
         *
         *   运行状态:  线程池初始化后，就处于该状态：此时，线程池可以接受新任务并且处理任务
         *   关闭状态:  调用shutdown()方法时，就处于该状态：此时，shutdown()方法之后不能再提交新任务，线程池会把shutdown()方法之前提交的任务按照线程池工作原理的步骤都处理完毕。（请参考我的博客：线程池工作原理）
         *   停止状态:  调用shutdownNow()方法时，就处于该状态：此时，shutdownNow()方法之后不能再提交新任务，线程池不处理已经提交到任务队列中的任务，线程池尝试中断正在执行的工作线程
         *   整理状态:  线程池内部自己使用的状态：当线程池queue任务队列为空，hashset<worker>为空时，就是该状态，该状态是由关闭状态/停止状态转变而来的。当处于整理状态时，线程池会调用terminated()钩子方法
         *   终结状态:  当钩子方法terminated()执行完毕之后，线程池由整理状态转变为终结状态。钩子方法是线程池自动调用的。
         *
         *   在线程池终结状态之前，可以调用awaitTermination()阻塞方法，使当前主线程阻塞，直至线程状态转变为终结状态
         */ 
    
     /**
     * The main pool control state, ctl, is an atomic integer packing
     * two conceptual fields
     *   workerCount, indicating the effective number of threads
     *   runState,    indicating whether running, shutting down etc
      *
      * The runState provides the main lifecycle control, taking on values:
      *
      *   RUNNING: Accept new tasks and process queued tasks
      *   SHUTDOWN: Don't accept new tasks, but process queued tasks
      *   STOP: Don't accept new tasks, don't process queued tasks, and interrupt in-progress tasks
      *   TIDYING: All tasks have terminated, workers is zero,the thread transitioning to state TIDYING
      *   TERMINATED: terminated() has completed
        *
        * RUNNING -> SHUTDOWN On invocation of shutdown(), perhaps implicitly in finalize()
        * (RUNNING or SHUTDOWN) -> STOP On invocation of shutdownNow()
        * SHUTDOWN -> TIDYING when both queue and pool are empty，will run the terminated() method
        * STOP -> TIDYING When pool is empty
        * TIDYING -> TERMINATED when the terminated() hook method has completed
        *
         * Threads waiting in awaitTermination() will return when the state reaches TERMINATED.
         */
        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; }
    
        .......
    
}

private static final int COUNT_BITS = Integer.SIZE - 3;            //8-3=5 活跃线程支持5位来表示个数
private static final int CAPACITY   = (1 << COUNT_BITS) - 1; //1左移5位-1（1*2的5次方-1），也就是31个线程（低5位）   也就是00000001左移5位是00100000，然后再减00000001得到最终结果00011111将低5位标识线程数的部分保留

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;       // -1即11111111 左移5位后为11100000 表示运行状态（高3位）
private static final int SHUTDOWN   =  0 << COUNT_BITS;    //  0即00000000 左移5位后为00000000 表示关闭状态（高3位）
private static final int STOP       =  1 << COUNT_BITS;           //  1即00000001 左移5位后为00100000 表示停止状态（高3位）
private static final int TIDYING    =  2 << COUNT_BITS;         //  2即00000010 左移5位后为01000000 表示关闭状态（高3位）
private static final int TERMINATED =  3 << COUNT_BITS;   //  3即00000011 左移5位后为01100000 表示关闭状态（高3位）

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); 
private static int ctlOf(int rs, int wc) { return rs | wc; }

ctl.compareAndSet(expect, update); //这个操作是原子操作，表示设置当前ctl的值。

public final boolean compareAndSet(int expect, int update)