细说线程池---高级篇

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        ///1.当前池中线程比核心数少，新建一个线程执行任务
        //workerCountOf计算出线程个数
        if (workerCountOf(c) < corePoolSize) {
            //线程池中创建一个线程worker
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        ////2.核心池已满，但任务队列未满，添加到队列中
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //任务成功添加到队列以后，再次检查是否需要添加新的线程，
            // 因为已存在的线程可能被销毁了
            if (! isRunning(recheck) && remove(command))
                ////如果线程池处于非运行状态，
                // 并且把当前的任务从任务队列中
                //移除成功，则拒绝该任务
                reject(command);
            ////如果之前的线程已被销毁完，新建一个线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        ////3.核心池已满，队列已满，试着创建一个新线程
        else if (!addWorker(command, false))
            ////如果创建新线程失败了，说明线程池被关闭或者线程池完全满了， 拒绝任务
            reject(command);
    }

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING,0));

private static int ctlOf(int rs, int wc) { return rs | wc; }

-1 的二进制是 32 个 1（1111 1111 11111111 1111 1111 1111 1111）；

//32-3
private static final int COUNT_BITS = Integer.SIZE - 3;
//将 1 的二进制向右位移 29 位,再减 1 表示最大线程容量
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 运行状态保存在 int 值的高 3 位 ( 所有数值左移 29 位 )
// 接收新任务,并执行队列中的任务
private static final int RUNNING = -1 << COUNT_BITS;
// 不接收新任务,但是执行队列中的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 不接收新任务,不执行队列中的任务,中断正在执行中的任务
private static final int STOP = 1 << COUNT_BITS;
// 所有的任务都已结束,线程数量为 0,处于该状态的线程池即将调用 terminated()方法
private static final int TIDYING = 2 << COUNT_BITS;
// terminated()方法执行完成
private static final int TERMINATED = 3 << COUNT_BITS;

  private boolean addWorker(Runnable firstTask, boolean core) {
        //goto 语句,避免死循环
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            //如果线程处于非运行状态，并且 rs 不等于 SHUTDOWN 且 firstTask 不等于空且且
           // workQueue 为空，直接返回 false （表示不可添加 work 状态）
          //  1.  线程池已经 shutdown 后，还要添加新的任务，拒绝
           // 2.  （第二个判断） SHUTDOWN 状态不接受新任务，但仍然会执行已经加入任务队列的任
           // 务，所以当进入 SHUTDOWN 状态，而传进来的任务为空，并且任务队列不为空的时候，是允许添加
           // 新线程的 , 如果把这个条件取反，就表示不允许添加 worker
            if (rs >= SHUTDOWN &&
                    ! (rs == SHUTDOWN &&
                            firstTask == null &&
                            ! workQueue.isEmpty()))
                return false;
            for (;;) { //自旋
                int wc = workerCountOf(c);//获得 Worker 工作线程数
                //如果工作线程数大于默认容量大小或者大于核心线程数大小，
                // 则直接返回 false 表示不能再添加 worker。
                if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //通过 cas 来增加工作线程数，
                if (compareAndIncrementWorkerCount(c))
                //如果 cas 失败，则直接重试
                break retry;
                // 再次获取 ctl 的值
                c = ctl.get();
                //这里如果不想等，说明线程的状态发生了变化，继续重试
                if (runStateOf(c) != rs)
                continue retry;
            }
        }
        //上面这段代码主要是对 worker 数量做原子+1 操作,
        // 下面的逻辑才是正式构建一个 worker
        boolean workerStarted = false; //工作线程是否启动的标识
        boolean workerAdded = false; //工作线程是否已经添加成功的标识
        Worker w = null;
        try {
            //构建一个 Worker，这个 worker 是什么呢？
            //我们 可以看到构造方法里面传入了一个 Runnable 对象
            w = new Worker(firstTask);
            final Thread t = w.thread; //从 worker 对象中取出线程
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock(); //这里有个重入锁，避免并发问题
                try {
                    int rs = runStateOf(ctl.get());
                   //只有当前线程池是正在运行状态，[或是 SHUTDOWN
                    // 且 firstTask 为空]，才能添加到 workers 集合中
                    if (rs < SHUTDOWN ||
                            (rs == SHUTDOWN && firstTask == null)) {
                    //任务刚封装到 work 里面，还没 start,你封装的线程就是 alive，
                    // 几个意思？肯定是要抛异常出去的

                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w); //将新创建的 Worker 添加到 workers 集合中
                        int s = workers.size();
                      //如果集合中的工作线程数大于最大线程数，
                      // 这个最大线程数表示线程池曾经出现过的最大线程数
                        if (s > largestPoolSize)
                            largestPoolSize = s; //更新线程池出现过的最大线程数
                        workerAdded = true;//表示工作线程创建成功了
                    }
                } finally {
                    mainLock.unlock(); //释放锁
                }
                if (workerAdded) {//如果 worker 添加成功
                    t.start();//启动线程
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                //如果添加失败，就需要做一件事，就是递减实际工作线
                //程数(还记得我们最开始的时候增加了工作线程数吗)
                addWorkerFailed(w);

        }
        //返回结果
        return workerStarted;
    }

//继承了AQS还实现了Runnable
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;

        //注意了，这才是真正执行task的线程，从构造函数可知是由
         //ThreadFactury 创建的
        final Thread thread;
        //这就是需要执行的 task
        Runnable firstTask;
        /** 每个线程完成任务的计数器*/
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            //// 初始状态 -1, 防止在调用 runWorker() ，
            // 也就是真正执行task前中断thread 。
            setState(-1);  
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer 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;
        }

        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) {
                }
            }
        }
    }

    private void addWorkerFailed(java.util.concurrent.ThreadPoolExecutor.Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        //上锁
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            //释放锁
            mainLock.unlock();
        }
    }