Java线程池源码分析

       上一篇中我们主要对java线程池的概念，线程池中几个重要参数以及常用的四种线程池做了简单的介绍，今天我们就从源码入手，深入分析线程池是怎么玩的。

一、Executor架构

请看图：

1.Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。

2.ThreadPoolExecutor是线程池的核心类，用来执行被提交的任务。

3.ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令，该类功能比Timer更强大。

4.Future接口和实现Future接口的FutureTask类，代表异步计算的结果。

5.Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

二、Executor框架使用示意图

由图可以看出来，主线程首先需要创建实现Runnable或者Callable接口的任务对象。工具类Executors可以通过下面两个方法 把一个Runnable对象封装成一个Callable接口对象：

（1）Executors.callable(Runnable task)

（2）Executors.callable(Runnable task, Object result)

然后可以把Runnable对象直接交给ExecutorService执行ExecutorService.execute(Runnable command)；或者也可以把Runnable对象或Callable对象提交给ExecutorService 执行 ExecutorService.submit(Runnable task) 或 ExecutorService.submit(Callable<T>task)。

如果执行ExecutorService.submit(…)，ExecutorService 将返回一个实现 Future 接口的对象（到目前为止的JDK中，返回的是FutureTask对象）。由于FutureTask实现了Runnable，程序员也可以创建FutureTask，然后直接交给ExecutorService执行。

最后，主线程可以执行 FutureTask.get() 方法来等待任务执行完成。主线程也可以执行
FutureTask.cancel(boolean mayInterruptIfRunning)来取消此任务的执行。

引自：https://blog.csdn.net/lxk_1993/article/details/90672654
三、源码分析

1.ThreadPoolExecutor

该类是线程池的核心类，继承自AbstractExecutorService类（该类实现了ExecutorService接口）

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;

该类成员变量ctl使用高3位表示线程池的运行状态，使用低29位表示线程池中的线程数。

下面我们介绍一下线程池中最最核心的方法，那就是execute方法。我们看看ThreadPoolExecutor的execute方法，代码如下：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, 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. If a task can be successfully queued, then we still need
         * to double-check 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.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        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);
    }

从源码中我们可以看出，当有一个任务提交给线程池的时候，首先会对提交的任务进行非空判断，保证任务的存在性。如果非空任务提交到线程池，那么线程池会从成员变量ctl中获取值，上面我们提到过该成员变量功能很强大，高3位保存了线程池的状态，低29位保存了线程池中线程的数量。通过workerCountOf()方法获取到当前线程池中线程的数量，判断当前线程池中线程数和核心线程数的大小。如果当前线程池中线程数比核心线程池数小，那么就调用addWorker(Runnable command,true)方法创建一个新线程来执行任务。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;
                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 {
            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;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

从源码我们可以看出addWorker方法中使用了一个for循环，看起来是一个无限循环，但是在最前面定义了一个retry标记，可以用来终止循环，这个嵌套的for循环主要用来检查目前的线程池环境能否支持正常创建新的线程来执行任务。如果当前线程池的环境支持正常的创建新线程，那么就会执行创建新线程的逻辑。

创建新线程的时候会首先创建一个worker对象，把当前任务传递给worker对象。在worker对象的构造方法中会使用ThreadFactory创建一个新的线程。ThreadPoolExecutor中维护了一个workers的HashSet用来存放所有的worker对象。

将创建好的worker对象放到workers中。如果该步骤成功，那么execute方法直接返回，失败则尝试进入阻塞队列。判断线程池是否为运行状态并且任务队列是否可以继续存放任务。入队列成功，检查线程池状态，如果状态部署RUNNING而且remove成功，则拒绝任务。如果当前worker数量为0，通过addWorker(null, false)创建一个线程，其任务为nul。如果上述步骤均失败则尝试将线程池的数量由corePoolSize扩充至maxPoolSize，如果失败则拒绝任务。

addWorker共有四种传参方式。execute使用了其中三种，分别为:

1.addWorker(paramRunnable, true)

线程数小于corePoolSize时，放一个需要处理的task进Workers Set。如果Workers Set长度超过corePoolSize，就返回false。

2.addWorker(null, false)

放入一个空的task进workers Set，长度限制是maximumPoolSize。这样一个task为空的worker在线程执行的时候会去任务队列里拿任务，这样就相当于创建了一个新的线程，只是没有马上分配任务。

3.addWorker(paramRunnable, false)

当队列被放满时，就尝试将这个新来的task直接放入Workers Set，而此时Workers Set的长度限制是maximumPoolSize。如果线程池也满了的话就返回false。