上次的线程池文章阐释了相关概念，这次就简单的看看源码中的核心部分。

ThreadPoolExecutor类的几个重要的类属性和方法

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

这里的ctl值是个AtomicInteger原子变量，COUNT_BITS为32 - 3是29位，CAPACITY便为(1 << 29) - 1，一共后29位置1，所以ctl这一个值是当做两个变量去用的，高四位是线程状态信息，低29位是当前线程数量信息。

然后看核心方法，我直接写在注释里。

public void execute(Runnable command) {
    	// 为null的话报空指针异常
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. 如果当前运行的线程数少于corePoolSize, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. 如果任务被成功加入进阻塞队列, then we still need
         * to 二次检查 whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
    	// clt记录runState和workerCount
        int c = ctl.get();
    	/*
     	 * workerCountOf方法取出低29位的值，表示当前活动的线程数；
         * 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中；
     	 * 并把任务添加到该线程中。
     	 */
        if (workerCountOf(c) < corePoolSize) {
            /*
         	 * addWorker中的第二个参数表示限制添加线程的数量的判断依据；
         	 * 如果为true，根据corePoolSize来判断；
         	 * 如果为false，则根据maximumPoolSize来判断
         	 */
            if (addWorker(command, true))
                return;
            // 如果添加失败，则重新获取ctl值
            c = ctl.get();
        }
    	// 如果当前线程池是运行状态并且任务添加到队列成功
        if (isRunning(c) && workQueue.offer(command)) {
            // 源码注释提到的二次检查
            int recheck = ctl.get();
            /*
             * 再次判断线程池的运行状态，如果不是运行状态
             * 由于之前已经把command添加到workQueue中了，这时需要移除该command
             * 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
             */
            if (! isRunning(recheck) && remove(command))
                reject(command);
            /*
         	 * 获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
         	 * 这里传入的参数表示：
         	 * 1. 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
         	 * 2. 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断；
         	 * 如果判断workerCount大于0，则直接返回，在workQueue中新增的command会在将来的某个时刻被执行。
         	 */
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
    	/*
     	 * 如果执行到这里，有两种情况：
     	 * 1. 线程池已经不是RUNNING状态；
     	 * 2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。
     	 * 这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize；
     	 * 如果失败则拒绝该任务
     	 */
        else if (!addWorker(command, false))
            reject(command);
    }

这里要注意一下addWorker(null, false);，也就是创建一个线程，但并没有传入任务，因为任务已经被添加到workQueue中了，所以worker在执行的时候，会直接从workQueue中获取任务。所以，在workerCountOf(recheck) == 0时执行addWorker(null, false);是为了保证线程池在RUNNING状态下必须要有一个线程来执行任务。