ThreadPoolExecutor源码解析(jdk1.8)

概述

线程池解决两个不同的问题：由于减少了每个任务的调用开销，它们通常在执行大量异步任务时提供了更好的性能，并且提供了在执行任务集合时绑定和管理资源(包括线程)的方法。每个ThreadPoolExecutor还维护一些基本统计信息，比如已完成任务的数量。为了在广泛的上下文中起到作用，该类提供了许多可调参数和可扩展钩子。ThreadPoolExecutor将根据corePoolSize和maximumPoolSize设置的边界自动调整池大小。

核心线程、最大线程池的线程数量

当方法execute()中提交了一个新任务，并且运行的线程小于corePoolSize时，即使其他工作线程处于空闲状态，也将创建一个新线程来处理请求。如果运行的线程大于corePoolSize但小于maximumPoolSize，则仅当队列已满时才会创建一个新线程。通过将corePoolSize和maximumPoolSize设置为相同的值，可以创建一个固定大小的线程池。通过将maximumPoolSize设置为一个本质上无界的值，如Integer.MAX_VALUE，您允许池容纳任意数量的并发任务。最典型的情况是，内核和最大池大小仅在构建时设置，但也可以使用setCorePoolSize和setMaximumPoolSize动态更改它们。

按需构建线程池

默认情况下，即使是核心线程也只是在新任务到达时才初始创建和启动，但是可以使用#prestartCoreThread或#prestartAllCoreThreads方法动态地覆盖这一点。如果使用非空队列构造池，您可能希望预启动线程。

创建新线程

使用ThreadFactory创建新线程。如果没有另外指定，则使用executor #defaultThreadFactory，它创建的线程都位于相同的ThreadGroup中，并且具有相同的NORM_PRIORITY优先级和非守护进程状态。通过提供一个不同的ThreadFactory，您可以更改线程的名称、线程组、优先级、守护进程状态。
如果ThreadFactory无法创建一个线程的时候，将会会返回null,执行程序会继续,但可能无法执行任何任务。线程应该拥有修改线程的运行时权限。如果工作线程或正在使用线程池的其他线程不拥有此权限，服务可能会降级:配置更改可能不会及时生效，关闭池可能仍然处于可能终止但尚未完成的状态。

保活时间

如果当前池中有超过corePoolSize的线程，如果空闲时间超过keepAliveTime，多余的线程将被终止。这提供了一种在池没有被积极使用时减少资源消耗的方法。如果池稍后变得更活跃，将构造新的线程。还可以使用方法#setKeepAliveTime(long，TimeUnit)动态更改此参数。使用以纳秒为单位的保活时间有效地使空闲线程的状态从终止到关闭已达到不可用。默认情况下，keep-alive策略仅适用于拥有多于corePoolSize线程的情况。但是方法#allowCoreThreadTimeOut(boolean)也可以用于将超时策略应用于核心线程，只要keepAliveTime值是非零的。

任务队列

任何BlockingQueue都可以用来传输和保存提交的任务。此队列的使用与池大小进行交互：

1. 如果运行的线程小于corePoolSize，则执行程序将会添加新线程来处理新来的任务而不是将任务放入任务队里中。
2. 如果正在运行的线程多于corePoolSize的线程，那么执行器总是倾向于对请求进行排队，而不是添加新线程。
3. 如果一个请求不能排队，那么将创建一个新线程来处理不能入队的新任务。如果此时的线程的数量超过maximumPoolSize的话，那么新来的任务将被拒绝。

三种常见的任务入队的策略

1.直接传递
工作队列的一个很好的默认选择是SynchronousQueue，它将任务传递给那些没有占有这些任务的线程。在这里，如果没有立即可用的线程来运行任务，则对任务进行排队的尝试将失败，因此将构造一个新线程。此策略在处理可能具有内部依赖项的请求集时可以避免锁定。直接切换通常需要无界的最大池大小，以避免拒绝新提交的任务。相反的情况下，当命令到达的平均速度持续快于它们能够被处理的速度时，可能会出现无限制的线程增长。
2.无界队列
使用无界队列(例如，LinkedBlockingQueue没有预定义的容量)将导致在所有核新池大小的线程都处于繁忙状态时，新任务在队列中等待。因此，不会创建超过corePoolSize的线程。因此，maximumPoolSize的值没有任何影响。当每个任务完全独立于其他任务时，这可能是合适的，因此任务不会影响其他任务的执行；例如，在web页面服务器中。而这种类型的排队可以有效地消除请求的瞬间爆发，例如，在web页面服务器中。尽管这种类型的排队可以有效地消除短暂的请求爆发，但也要明白这一点，当命令的平均到达速度超过它们的处理速度时，工作队列可能会无限制地增长。
3.有界队列
当使用有限的maximumpoolsize时，有界队列(例如ArrayBlockingQueue)有助于防止资源耗尽，但调优和控制可能更困难。队列大小和最大池大小可以相互适配:使用大队列和小池可以最小化CPU使用、OS资源和上下文切换开销，但是可能会导致人为的低吞吐量。如果任务经常阻塞(例如，如果它们是I/O绑定的)，系统可能能够为比其他方法允许的更多的线程安排时间。使用小队列通常需要更大的核心池大小，这会使cpu更忙，但可能会遇到不可接受的调度开销，这也会降低吞吐量。

任务的拒绝

在方法execute(Runnable)在执行程序关闭时提交的新任务将被拒绝，在执行程序对最大线程和工作队列容量都有有限的使用界限，也就是资源已经饱和时也将被拒绝。在这两种情况下，execute方法调用其RejectedExecutionHandler的rejectedExecution(Runnable, ThreadPoolExecutor)方法。
提供了四个预定义的处理程序策略：

1. 在默认的ThreadPoolExecutor.AbortPolicy中。处理程序在拒绝时抛出运行时RejectedExecutionException。
2. ThreadPoolExecutor.CallerRunsPolicy。调用execute本身的线程运行任务。这提供了一个简单的反馈控制机制，可以降低新任务提交的速度。
3. ThreadPoolExecutor.DiscardPolicy。无法执行的任务被简单地删除。如果执行器没有关闭，则删除工作队列头部的任务，然后重试执行(可能再次失败，导致重复执行)。
4. ThreadPoolExecutor.DiscardPolicy。无法执行的任务被简单地删除。

可以定义和使用其他类型的RejectedExecutionHandler类。这样做需要一些注意，特别是当策略设计为仅在特定容量或队列策略下工作时。

钩子方法

这个类提供了受保护的可覆盖的beforeExecute (Thread, Runnable)和afterExecute(Runnable, Throwable)方法，这些方法在执行每个任务之前和之后调用。这些可以用来操作执行环境;例如，重新初始化threadlocal、收集统计信息或添加日志条目。此外，terminated()可以被重写来执行那些一旦执行器已经完成的任何流程。
如果钩子或回调方法抛出异常，内部工作线程可能会失败并突然终止。

队列的维护

方法getQueue()允许访问工作队列，用于监视和调试。强烈反对将此方法用于任何其他目的。提供的两个方法remove(Runnable)和purge可用于在取消大量排队任务时帮助存储回收。

终止化

没有程序中引用的且没有剩余线程的线程池将自动关闭。如果您想确保即使用户忘记调用shutdown也要回收未引用的池的话，那么必须通过设置适当的保持活动时间(使用0个核心线程的下限)和设置allowCoreThreadTimeOut(布尔值)来安排未使用的线程最终死亡。

源码解析

先看看重要的全局变量
1.主池控制状态ctl是一个原子整数，包含两个概念字段：
workerCount，表示线程的有效数量
runState，指示是否运行、关闭等
2.为了将它们包装成一个整型来表示，我们将workerCount限制为(2^{29)-1(大约5亿)个线程，而不是(2}31)-1(20 * 10亿)个线程。如果将来出现这样的问题，可以将变量更改为AtomicLong，并调整下面的shift/mask常量。但是在需要之前，使用int可以使这段代码更快更简单。
3.workerCount是允许开始和不允许停止的工作线程的数量。该值可能与实际活动线程的数量有暂时的不同，例如当ThreadFactory在被请求时无法创建线程，以及在终止前已经退出的线程仍在执行记录下的任务时。用户可见的池大小被报告作为当前工作线程集合的大小。
4.runState提供主要的生命周期控制，采用下面的值：

state	explain	value
RUNNING	接受新任务并处理排队的任务	1010 0000 0000 0000 0000 0000 0000 0000
SHUTDOWN	不接受新任务，但是处理排队的任务	0000 0000 0000 0000 0000 0000 0000 0000
STOP	不接受新任务，不处理排队的任务，并且中断正在进行的任务	0010 0000 0000 0000 0000 0000 0000 0000
TIDYING	所有任务都已终止，workerCount为零，过渡到清理状态的线程将运行terminate()方法	0100 0000 0000 0000 0000 0000 0000 0000
TERMINATED	terminated()方法已经终止	0110 0000 0000 0000 0000 0000 0000 0000

5.为了允许有序比较，这些值之间的数值转换顺序很重要。运行状态会随着时间单调地增加，但不需要达到每个状态，状态的所有转换情况如下：

transitions	explain
RUNNING -> SHUTDOWN	调用shutdown()，可能在finalize()中隐式调用
(RUNNING or SHUTDOWN) -> STOP	调用shutdownNow()时
SHUTDOWN -> TIDYING	当队列和池都为空时
STOP -> TIDYING	当池为空时
TIDYING -> TERMINATED	当terminated()方法完成时

当状态达到终止时，在awaitterminate()中等待的线程将返回。

来看看构造方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}

构造器参数的含义:

parameter	explain
corePoolSize	线程池中存在的核心线程的数量，就算这些线程是空闲的也会保持这个数据。如果要取消这个性质，可以通过设置allowCoreThreadTimeOut()
maximumPoolSize	池中允许的最大线程数
keepAliveTime	当线程数大于内核时，这是多余的空闲线程在终止之前等待新任务的最长时间
unit	keepAliveTime参数的时间单位
workQueue	保存任务的队列，这个队列只包含execute方法提交的Runnable类型的任务
threadFactory	执行器创建新线程时使用的工厂，可以继承threadFactory类，定制线程名称等属性的生成
handler	由于达到线程边界和队列容量而阻塞执行时使用的处理程序，也可以设置自定义的新任务的拒绝策略

来看看核心方法：

在将来某个时候执行给定的任务。任务可以在新线程中执行，也可以在现有的池线程的线程中执行。如果无法提交任务供执行，或者因为这个执行器已经关闭，或者因为它的容量已经达到限制，那么该任务将由当前RejectedExecutionHandler处理。
执行器的处理流程分为三步：

1. 如果线程池中正在运行的线程的数量小于corePoolSize，那么创建一个新的线程并把新来的一个任务作为线程的第一个任务来执行。对addWorker的调用原子性地检查runState和workerCount，因此可以通过返回false来防止错误警报，因为错误警报会在不应该添加线程的时候添加线程。
2. 如果一个任务可以成功排队，那么我们仍然需要再次检查是否应该添加一个线程(因为自上次检查以来已有的线程已经死亡)，或者在进入这个方法后线程池关闭。因此，我们重新检查状态，如果必要的话，如果停止，则回滚队列;如果没有，则启动一个新线程。
3. 如果无法对任务排队，则尝试添加新线程。如果它失败了，我们知道线程池已经被关闭或已经饱和，所以拒绝任务。

---

来看看全局变量

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

深层次的看看ctlOf的计算原理：
ctlOf实际上就是把runState和workCount的数据柔和在一次，同个ctl就能计算出这两个值，也是很方便的
ctl = rs | wc;
假设现在线程池的状态时Running，工作中线程的数量是2个：
1010 0000 0000 0000 0000 0000 0000 0000
|
0000 0000 0000 0000 0000 0000 0000 0010
1010 0000 0000 0000 0000 0000 0000 0010
在看看如何从ctl中获取线程池的runState的？
runState = ctl & ~CAPACITY
1010 0000 0000 0000 0000 0000 0000 0010
&
1110 0000 0000 0000 0000 0000 0000 0000
1010 0000 0000 0000 0000 0000 0000 0000
可以看出结果=rs,再来验证一下workerCount？
workerCount = ctl & CAPACITY
1010 0000 0000 0000 0000 0000 0000 0010 & 0001 1111 1111 1111 1111 1111 1111 1111 = 0000 0000 0000 0000 0000 0000 0000 0010
可以看出结果 = workerCount
总结一下：runState取的是ctl的前高三位，workerCount取得是ctl的低29位。

---

public void execute(Runnable command) {
            if (command == null)
                throw new NullPointerException();
            int c = ctl.get();
            if (workerCountOf(c) < corePoolSize) {//  第一步，如果工作的线程的数量小于核心线程数，通过addWorker方法创建新线程处理新来的任务
                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);// 执行拒绝策略
    }

---

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);// 重复性的原子检查防止错误警报

            // 检查队列是否为空
            // SHUTDOWN的状态表示线程池不在接受新的任务
            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))// workerCount添加成功后退出，之后进入创建新的新的线程来处理新任务
                    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);// 在后面去解析Worker.class
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;// 使用ReentrantLock的mainLock是因为可以序列化那些被中断的空闲的线程，特别在线程池在执行SHUTDOWNNOW的时候可以避免线程的干扰风暴。否则退出的线程会中断那些还未中断的线程。在线程池执行SHUTDOWN和SHUTDOWNNOW的时候使用mainLock确保workSet是稳定的，同时单独检查是否允许中断和实际的中断。
                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;
}
private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}
final void reject(Runnable command) {
    handler.rejectedExecution(command, this);// 执行拒绝策略，可以定制策略
}

再来看看Worker这个类是如何创建线程并执行第一任务的？
先看看构造函数？

Worker(Runnable firstTask) {
            setState(-1); // 这里设置成-1,在worker中只有两个状态，一个是-1,一个是0，-1是禁止当前的任务被干扰
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);// 使用threadFactory命名，并将当前worker对象绑定到线程中，实际上保存的worker中run中的方法提供给线程start
}

在来看看worker内部的锁机制是怎么样的？
先看看lock，业务逻辑在tryAcquire()

protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {// 这里表明只有当前锁处于空闲的时候才会加锁成功
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
}

在看看unlock，其实要看tryRelease()

protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
}

最后看worker最后执行的业务逻辑run（）

public void run() {
            runWorker(this);
 }
 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 回头看addWorker方法中将任务添加到workers集合成功之后开始调用worker线程的start方法启动线程，因为在worker初始化的时候已经将state设置成-1了，但是到了run方法的时候，线程池允许当前的worker线程被干扰，所以现在通过unlock将worker的状态归为0
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {// 走到这里说明新线程已经创建好了，getTask就是从定义ThreadPoolExecutors时存储任务的线程池的类型中获取任务
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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 {
            processWorkerExit(w, completedAbruptly);
        }
}
/*
*从线城池定义的队列中获取任务
*/
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
        	// 如果是定时任务的话，则使用队列的poll操作，可以实现超时处理并立刻返回结果（异常或者null，没有超时的话则返回处理结果）
        	// 如果不是定时任务的话，则使用队列的take操作，将当前线程阻塞，知道线程被唤醒获取任务
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

ThreadPoolExecutor的处理总之要接合任务队列的offer、poll、take操作
源码解析完毕，欢迎大家评论沟通！！！！