线程池工具ThreadPoolExecutor

JDK1.5中引入了强大的concurrent包，其中最常用的莫过了线程池的实现ThreadPoolExecutor，它给我们带来了极大的方便，但同时，对于该线程池不恰当的设置也可能使其效率并不能达到预期的效果，甚至仅相当于或低于单线程的效率。

ThreadPoolExecutor类可设置的参数主要有：

• corePoolSize

在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，（除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程）。

默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

• maxPoolSize

当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池会拒绝处理任务而抛出异常。

• keepAliveTime

当线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。

• allowCoreThreadTimeout

是否允许核心线程空闲退出，默认值为false。

• queueCapacity

任务队列容量。从maxPoolSize的描述上可以看出，任务队列的容量会影响到线程的变化，因此任务队列的长度也需要恰当的设置。

还有就是 workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

1. ArrayBlockingQueue;
2. LinkedBlockingQueue;
3. SynchronousQueue;
4. PriorityBlockingQueue 

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

• threadFactory：线程工厂，主要用来创建线程；
• handler：表示当拒绝处理任务时的策略，有以下四种取值：

1. ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
2. ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
3. ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
4. ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程池按以下行为执行任务

1. 当线程数小于核心线程数时，创建线程。
2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数大于等于核心线程数，且任务队列已满
   1. 若线程数小于最大线程数，创建线程
   2. 若线程数等于最大线程数，抛出异常，拒绝任务

系统负载

参数的设置跟系统的负载有直接的关系，下面为系统负载的相关参数：

• tasks，每秒需要处理的最大任务数量
• tasktime，处理第个任务所需要的时间
• responsetime，系统允许任务最大的响应时间，比如每个任务的响应时间不得超过2秒。

参数设置

corePoolSize:

每个任务需要tasktime秒处理，则每个线程每钞可处理1/tasktime个任务。系统每秒有tasks个任务需要处理，则需要的线程数为：tasks/(1/tasktime)，即tasks*tasktime个线程数。假设系统每秒任务数为100~1000，每个任务耗时0.1秒，则需要100*0.1至1000*0.1，即10~100个线程。那么corePoolSize应该设置为大于10，具体数字最好根据8020原则，即80%情况下系统每秒任务数，若系统80%的情况下第秒任务数小于200，最多时为1000，则corePoolSize可设置为20。

queueCapacity:

任务队列的长度要根据核心线程数，以及系统对任务响应时间的要求有关。队列长度可以设置为(corePoolSize/tasktime)*responsetime： (20/0.1)*2=400，即队列长度可设置为400。

队列长度设置过大，会导致任务响应时间过长，切忌以下写法：

LinkedBlockingQueue queue = new LinkedBlockingQueue();

这实际上是将队列长度设置为Integer.MAX_VALUE，将会导致线程数量永远为corePoolSize，再也不会增加，当任务数量陡增时，任务响应时间也将随之陡增。

maxPoolSize:

当系统负载达到最大值时，核心线程数已无法按时处理完所有任务，这时就需要增加线程。每秒200个任务需要20个线程，那么当每秒达到1000个任务时，则需要(1000-queueCapacity)*(20/200)，即60个线程，可将maxPoolSize设置为60。

keepAliveTime:

线程数量只增加不减少也不行。当负载降低时，可减少线程数量，如果一个线程空闲时间达到keepAliveTiime，该线程就退出。默认情况下线程池最少会保持corePoolSize个线程。

allowCoreThreadTimeout:

默认情况下核心线程不会退出，可通过将该参数设置为true，让核心线程也退出。

以上关于线程数量的计算并没有考虑CPU的情况。若结合CPU的情况，比如，当线程数量达到50时，CPU达到100%，则将maxPoolSize设置为60也不合适，此时若系统负载长时间维持在每秒1000个任务，则超出线程池处理能力，应设法降低每个任务的处理时间(tasktime)。

平常我们经常都会使用到线程池，但是有没考虑过为什么需要使用线程池呢？下面我列举一下问题，大家可以思考一下
1.当前服务器的硬件环境是多少核的CPU，它和线程的关系又是什么？ 
2.jvm能创建多少个线程？ 
3.多线程主要解决什么问题？ 
4.你使用线程池的目的是什么？

以上几个问题都是帮助你更好的使用java的线程（还可以衍生更多的小问题，如：jvm维护线程的消耗，cpu调度线程的消耗，应该使用多少个线程才能最大化利用多核CPU..）。答案需要自己去百度，我这也讲不好，反而误导大家。

线程池顾名思义就是，存储了N多线程的一个池子，该池子维护了线程的创建、销毁，线程的创建数量，任务调度..
通常我们使用线程池，都是通过Executors 工厂方法来创建一个线程池。该工厂方法主要提供了以下几大类型线程池的创建：
1.CacheThreadPool 
这是一个线程数变动性非常强的线程池，默认配置下，它可以开启无限多个线程（Integer.maxSize 和
JVM允许线程数范围内）。且如果该线程池里的线程在60秒内如果是处于空闲状态（即没任务执行），那么该线程就会被回收，不再由线程池维护。如果有新任务进来时，由于之前的线程池里的线程已被回收，那么新的线程也会再次创建。当执行完任务，60秒内依旧无新任务的可执行话，那么该线程又会被再次回收。

综合该线程池的特性，我们可以思考下什么情况下应该使用这类线程池。比如：我们的应用服务器上面，会在非固定时间（时间跨域度会尽可能大）和非固定的任务数量。

2.FixedThreadPool
FixedThreadPool一个固定数量的线程池，且该线程池不会随着任务的变化而增多或减少线程数量。即该线程池下的线程池如果你不主动调用销毁shutdowm、purge之类的方法。那么这些线程将会永远被线程池维护着。

3.SingleThreadExecutor
SingleThreadExecutor是一个固定单线程的线程池，该线程池会永远都保持着一个线程的活动状态，如果该线程池的单线程因某些异常而退出后，线程池会继续创建一个新的线程。

4.ScheduledThreadPool
ScheduledThreadPool是一个支持任务定时调度的线程池。

以上四种线程池，除了ScheduledThreadPool，其他三种都是通过创建一个ThreadPoolExecutor对象来实现的，只是在构造该对象时候，初始化该内部的成员变量值不同，所以造就了其他三种类型的线程池的存在。下面看看ThreadPoolExecutor都有些什么成员变量，他们又分别有什么意义？
以下是ThreadPoolExecutor的构造方法之一，而Executors都是通过该构造方法来创建其他三种不同的线程池的。

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

/**
在说这些参数之前，需要先了解下线程池内部的一些工作机制。
线程池ThreadPoolExecutor会自动调节线程池的大小（看ThreadPoolExecuroe.getPoolSize），依据corePoolSize参数的范围大小和maximumPoolSize。
当一个新任务通过ThreadExecutor.execute或者submit被提交时，
    如果当前线程池中的线程数量小于所设定的corePoolSize，一个新的线程则会被创建来处理该请求，即使这些核心的线程池是空闲的（当前没有处理任何任务）。
    如果当前线程池中的线程数量等于所设定的corePoolSize，那么新提交的任务则不会再创建新的线程，而是把该任务放进线程池所维护的任务队列workQueue中。当其他线程执行完了任务那么则会从任务队列中持续的获取任务来执行。
只有当前线程池中的数量超过了corePoolSize但是小于maximumPoolsize，且当queue满了才会去创建新线程（该创建的新线程必须小于maximumPoolsize）来处理该请求。
以下是该构造方法的参数说明：
corePoolSize : 线程池的核心线程数。该参数并不是初始化时候写死了，线程池对象构造完成以后也能通过它提供的一些方法动态修改，ThreadPoolExecutor.setCorePoolSize。
maximumPoolSize ： 线程池的最大线程数，只有当任务队列满了才会创建新的线程。该参数并不是初始化时候写死了，线程池对象构造完成以后也能通过它提供的一些方法动态修改，ThreadPoolExecutor.setMaximumPoolSize。
keepAliveTime ： 线程池所维护的线程的活动时间。如果超过了该时间范围，而线程还是空闲的，那么该线程将会被回收。不再由线程池所维护。以下是官方的一些说明：
如果当前线程池数大于核心线程池数，且这些线程是空闲的超过所设定的存活时间keepAliveTime，那么这些多出来的线程则会被终止，可以降低线程资源消耗。通过设置尽可能大的过期时间来阻止空闲线程被销毁，可手动调用setKeepAliveTime来设置。默认情况下，该策略只能适用于大于核心线程数的线程，但是可以通过设置ThreadPoolExecutor.allowCoreThreadTimeOut(boolean)，则该策略也适用于核心线程数。
unit ： 和上面keepAliveTime所对应，表示活动时间的时间单位。如 毫秒、秒、分..
workQueue ： 初始化一组任务，但是该组任务并不会马上执行，需要手动调用prestartCoreThread或者prestartAllCoreThreads来预先启动线程才会执行这些初始化的任务。否则只有当你提交第一个任务时候他才会执行，且可能是单线程执行（取决于你提交几次任务）..
threadFactory : 传入一个线程工厂。通过该线程工厂可以创建线程。它创建的所有线程都是通过同样的ThreadGroup和同样的NORM_PRIORITY和non-daemon状态。通过提供的不同ThreadFactory，可以掌握修改线程名字，线程组，优先级，守护状态等。如果线程池调用线程工厂创建一个线程失败时，则返回一个null。且executor会继续，但是可能不会执行任何任务。
如果我们自己重写封装了一遍线程工厂，还有个好处就是可以通过该线程工厂实例维护所有由它创建的线程。
上次我在群里看到一个群友说，他去面试，面试官问他如何判断线程池中一个指定线程当前是否在执行任务，你们觉得可以吗？
**/

场景：重新初始化ThreadLocal。收集统计信息，添加日志记录。。

Queue maintenance
ThreadPoolExecutor.getQueue允许访问工作队列来完成监视和调试，但强烈不建议开发者使用它来完成其他目的。

上面说明了线程池的一些构造参数和外部方法，了解了这些后我们可以直接使用ThreadPoolExecutor来构建适合我们的线程池，而不再需要Executors。当然，通过Execturos创建的线程池再配合上面说的一些动态设置参数的方法，也能起到一些很好的效果。

准备开始解刨核心源码了！

先看看成员变量： 
参数runstate 
RUNNING：接收新任务和处理队列任务 
SHUTDOWN:不接收新任务，但处理队列里的任务 
STOP:不接收新任务，也不处理队列任务何中断正在执行的任务 
TERMINATED：和STOP一样 
以下是runstate状态的转换过程： 
RUNING->SHUTDOWN 调用shutdown() 
(RUNNING or SHUTDOWN) ->STOP 调用shutdownnow() 
SHUTDOWN->TERMINATED 当队列和线程池都是空的 
STOP->TERMINATED 当线程池是空的

workQueue： 
该成员变量是个阻塞队列，主要用于存储需要执行任务和把任务转交给worker线程

mainLock： 
用来对成员变量pooSize，corePoolSize，maximumPoolSize，runState、workers修改时候同步

termination： 
用来支持waitTemination

workers： 
集合包含的所有worker线程在线程池，只能通过mainLock访问

keepAliveTime： 
设置空闲线程等待多时毫秒被回收

allowCoreThreadTimeOut： 
设置核心线程空闲时候是否被回收，默认false

corePoolSize：核心线程数，需要使用mainLock同步更新

maximumPoolSize：最大线程数，需要使用mainLock同步更新

poolSize：当前线程数，需要使用mainLock同步更新

handler：当线程池饱和或者shutdown时候被执行

threadFactory： 线程工厂

largestPoolSize： 最大线程数，这个参数的存在似乎是为了更正并发情况下poolSize的修改

completedTaskCount：获取已完成的任务数量

defaultHandler：默认的拒绝处理器

addWorker失败的话可能会导致线程池关闭

通常我们把任务通过submit或者execute提交到线程池中，然后接着就什么都不用干，等待线程池帮我们执行任务了。那么线程池内部是如何执行这些任务的呢？它又是如何维护线程和任务的关系？
下面先看一幅关于线程池内部运作的图：

从图中可以看出Worker实现了Runnable接口且封装了线程（注意它在通过线程工厂创建线程时候把this，即Worker传入到Thread的构造参数）
在代码上是线程池维护了一组Worker，通过Worker.thread.start()后，那么Worker所封装的线程就会运行Worker自身的run实现。最后在run实现里持续的从workQueue中获取任务来执行，由于workQueue是阻塞队列，所以如果队列中没有任务，那么该线程则会被挂起等待唤醒（有任务过来），下面从源码中看看：

/**
Worker类里封装了Thread和任务Runnable，还有completedTasks。可以注意到创建一个Thread时候把this传入，这样的话如果我调用Worker.thread.start()就相当于该线程会执行Worker里的run方法了。completedTasks是用来记录该线程完成了多少个任务（非整个线程池）。
注意该Worker继承了AQS同步基础器，它主要实现了互斥锁的功能，但是这个互斥锁和ReentrantLock有点不同，该实现是不允许线程重入获取锁的。下面说说为什么要实现锁功能和非重入：
1.lock方法主要用在标明当前线程正在执行任务中，而private interruptIdleWorkers 方法需要使用tryLock来判断当前线程是否正在执行任务，如果非执行任务状态则表明可能是正在获取任务，那么该线程属于空闲状态，可以被中断。
2.看回答1可以知道这通过ReentrantLock也能实现，但是如果我们在提交一个任务给线程池（实现一个Runnable），如果该
任务里面调用了和interruptIdleWorkers相关的，需要中断当前可获取锁（代表空闲）的线程。如果我们不使用非重入锁，这个任务线程就会给中断，从而导致一些奇怪的问题。
**/
private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** 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;
            this.thread = getThreadFactory().newThread(this);
        }

        /**
         主要看这里，其他的都是关于AQS的实现，具体的可以看AQS源码+我的AQS源码分析篇。
        **/
        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;
        }

        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(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

看看Worker run的实现方法：

final void runWorker(Worker w) {
        /**
           这里获取当前执行线程，就是Worker所封装的Thread（因为是通过该Thread启动的，然后执行自身的run方法）
        **/
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        // 这个似乎没什么用的
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //如果存在第一个任务则直接执行该任务，否则从任务队列里阻塞获取任务
            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 {
                        //真正的执行任务代码
                        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 {
            //执行到这里代表该线程已被终止，将被回收（从线程池的workers里删除该线程）。
            //这个方法同时也代表了当线程超出了空闲时间后，将不再由线程池维护，而是被GC回收。具体可以看
            //getTask。由于getTask是以阻塞方式从阻塞队列获取任务，可以通过阻塞获取时候设定一个阻塞时间
            //来达到 keepAliveTime空闲功能。
            processWorkerExit(w, completedAbruptly);
        }
    }

下面看看getTask是如何实现 线程池维护线程的keepAliveTime功能的。

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        retry:
        for (;;) {
            int c = ctl.get();
            //获取当前线程池的状态（这部分具体最后讲）
            int rs = runStateOf(c);

            // 如果线程池已被shutdown或者由于其他原因关闭，那么则终止该线程，返回null，最后就会走
            //processWorkerExit方法 了
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            boolean timed;      // Are workers subject to culling?

            for (;;) {
                //获取线程池当前的线程数（worker数量则代表线程数）
                int wc = workerCountOf(c);
                //判断是否需要采取设置 阻塞时间的方式获取任务.如果核心线程也需要空闲回收或者当前线程数
                //量已经超越了核心线程数，那么都需要采取阻塞时间获取任务方式。
                timed = allowCoreThreadTimeOut || wc > corePoolSize;
                //判断是否需要跳出循环，循环仅仅只是为了cas修改减少线程池的线程数。
                if (wc <= maximumPoolSize && ! (timedOut && timed))
                    break;
                // 执行到这里代表阻塞获取任务超时，keepAlivetime时间到了。该线程将被回收
                if (compareAndDecrementWorkerCount(c))
                    return null;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }

            try {
                //如果需要采用阻塞形式获取，那么就poll设定阻塞时间，否则take无限期等待。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

看了上面知道了线程池最核心的Worker是如何持续处理任务队列中的任务，和keepAlivetimed回收空闲线程。下面再看看execute一个任务后，线程池的处理步骤。比如核心线程数和最大线程数的体现，线程启动等 public void execute(Runnable command) {

        if (command == null)
            throw new NullPointerException();

        int c = ctl.get();
        //判断当前线程池的线程数是否少于核心线程数，只要少于核心线程数都会addWorker创建一个新Worker(新线程)
        //来处理新任务
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //当前线程数大于核心线程数或者addWroker失败，需要把任务提交到任务队列，等待Worker线程空闲后处理
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //判断当前线程池状态是否正在运行（防止前面判断时候出现并发问题）
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //如果当前线程池数量为0则创建新线程。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //执行到这里代表当前线程已超越了核心线程且任务提交到任务队列失败。（可以注意这里的addWorker是false）
        //那么这里再次调用addWroker创建新线程（这时创建的线程是maximumPoolSize）。
        //如果还是提交任务失败则调用reject处理失败任务
        else if (!addWorker(command, false))
            reject(command);

    }

    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 (;;) {
                int wc = workerCountOf(c);
                //当前线程池的数量已经达到限定，不能添加新的线程了！
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //cas修改增加线程池所拥有的线程数
                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 {
            final ReentrantLock mainLock = this.mainLock;
            //创建一个新的Worker，则封装了一个firstTask
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int c = ctl.get();
                    int rs = runStateOf(c);

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        //提交Worker到线程池所维护的workers集合中（可以认为这是一组线程）
                        workers.add(w);
                        int s = workers.size();
                        if (s >

最后就是关于该篇源码开头的ctl 值问题了，ctl里面的值包含了两类值，一个是当前的线程池运行状态，一个是线程池的当前线程数量。至于如何理解这里面的逻辑，需要有位运算基础，可以结合以下代码来观察他们的位运算关系

public class X {
    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; }

    public static void main(String[] args) {
        System.out.println("COUNT_BITS:"+COUNT_BITS+"   "+Integer.toBinaryString(COUNT_BITS));
        System.out.println("CAPACITY:"+CAPACITY+"   "+format(Integer.toBinaryString(CAPACITY)));
        System.out.println("RUNNING:"+RUNNING+"   "+format(Integer.toBinaryString(RUNNING)));
        System.out.println("SHUTDOWN:"+SHUTDOWN+"   "+format(Integer.toBinaryString(SHUTDOWN)));
        System.out.println("STOP:"+STOP+"   "+format(Integer.toBinaryString(STOP)));
        System.out.println("TIDYING:"+TIDYING+"   "+format(Integer.toBinaryString(TIDYING)));
        System.out.println("TERMINATED:"+TERMINATED+"   "+format(Integer.toBinaryString(TERMINATED)));
        System.out.println(runStateOf(TIDYING));
        System.out.println(format(Integer.toBinaryString(~CAPACITY)));
    }

    private static String format(String str){
        //if(str!=null) return str;

        char[] cs = str.toCharArray();
        StringBuilder sb = new StringBuilder();
        int j =0;
        for(int i=(cs.length-1); i>=0 ; i--){
            sb.append(cs[j++]);
            if(i % 4 ==0){
                sb.append(" ");
            }
        }
        return sb.toString();

    }

}