前言

众所周知，JDK为我们提供了一系列线程池类，ThreadPoolExecutor就是一个很典型的实现，以下对JDK的线程池机制分析都将围绕这一个类来描述。

开始

要使用ThreadPoolExecutor，我通常会这样做：

        //创建一个核心线程数为4的线程池
        ExecutorService es = Executors.newFixedThreadPool(4);
        Task t = new Task();
        for (int i = 0; i < 100; i++) {
            es.submit(t);
        }
        es.shutdown();

但是这里面发生了什么事，它的代码实现又是怎么一回事呢，我们来一探究竟。

细究

通过对submit方法打断点，我们可以发现，在AbstractExecutorService这个类里边半实现了submit方法

//AbstractExecutorService#submit
public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);//mark here
        return ftask;
}

为什么我说是“半实现”呢，因为在我mark的那行代码的execute(Runnable)方法仍然是一个抽象方法，在ThreadPoolExecutor类中，提供了对它的具体实现。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

//拿到当前的work（或者说是Runnable）数量
        int c = ctl.get();
//如果工作的线程小于核心线程数的话
        if (workerCountOf(c) < corePoolSize) {
//addWorker()方法里面会创建Worker类和对应的线程。
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
//如果大于核心线程数，就把这个Runnable对象command加入阻塞队列中，
//同时应该二次检查是否应该创建新的线程，
//如果线程池shutdown，就执行reject操作，就是拒绝服务了。
        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);
        }
//如果无法加入阻塞队列，直接拒绝服务
        else if (!addWorker(command, false))
            reject(command);
 }

再来看一下addWorker方法。

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操作成功增加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
            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();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
//执行到这里，Worker就算是创建成功了
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
//成功创建Worker之后，启动线程。
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
}

那这个Worker类到底是一个怎么样的数据结构呢，再来看一下。

Worker类
当我们创建一个Worker的时候，就把我们通过submit方法传递进来的Runnable给了firstTask属性，然后再通过工厂方法创建一个线程。同时Worker又是一个Runnable对象，在重写的run()方法中，调用了外部的runWorker(Worker)方法。
正如上文所讲的一样，创建了线程就会start()，每个线程所做的就是这里的run方法，再细化，就是runWorker(Worker)方法 runWorker方法

首先，把传递进来的Worker的Runnable对象给task，这时候的task局部对象有两种的取值，一种是我们直接submit进来的Runnable对象，另一种是null，出现null的情况是：当前线程的数量大于等于核心线程数量。
所以，在while循环的时候，我们才会用task != null || (task = getTask() != null)这种表示，getTask方法待会再看，它会在阻塞队列中获取Runnable对象。
拿到了task，就可以调用run方法了，因为我们现在就是在工作的线程里面。

最后，来看看getTask()方法。

最后的getTask()方法

getTask方法的外部包着一个死循环for(;;)，这是因为poll方法在阻塞队列空的时候并不会把当前线程阻塞住，它还会往下走。
但是如果boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;这条语句不成立，timed为false，就可以成功的将线程阻塞住，我找遍了ThreadPoolExecutor这个类，都没有找到allowCoreThreadTimeOut这个属性的赋值的地方，那么就默认成立false，所以，在阻塞队列拿Runnable对象就主要是take()方法了。

结尾

正是这样不停向阻塞队列拿Runnable或者创建规定数量的线程执行Runnable的机制，保证了线程池的正常运行，当然我今天记录下来的只是冰山一角，这里面还是有很多地方值得我们去研究，比如AQS类，CAS机制等等。才疏学浅，只敢写下这些了。