原文出处： 肖汉松

媒介

多线程编程中，为每个任务分派一个线程是不现实的，线程建设的开销和资源耗损都是很高的。线程池应运而生，成为我们打点线程的利器。Java 通过Executor接口，提供了一种尺度的要领将任务的提交进程和执行进程解耦开来，并用Runnable暗示任务。

下面，我们来阐明一下 Java 线程池框架的实现ThreadPoolExecutor。

下面的阐明基于JDK1.7

生命周期

ThreadPoolExecutor中，利用CAPACITY的高3位来暗示运行状态，别离是：

1. RUNNING：吸收新任务，而且处理惩罚任务行列中的任务
2. SHUTDOWN：不吸收新任务，可是处理惩罚任务行列的任务
3. STOP：不吸收新任务，不处理惩罚任务行列，同时间断所有举办中的任务
4. TIDYING：所有任务已经被终止，事情线程数量为 0，达到该状态会执行terminated()
5. TERMINATED：terminated()执行完毕

ThreadPoolExecutor顶用原子类来暗示状态位

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

线程池模子

焦点参数

corePoolSize：最小存活的事情线程数量（假如配置allowCoreThreadTimeOut，那么该值为 0）

maximumPoolSize：最大的线程数量，受限于CAPACITY

keepAliveTime：对应线程的存活时间，时间单元由TimeUnit指定

workQueue：事情行列，存储待执行的任务

RejectExecutionHandler：拒绝计策，线程池满后会触发

线程池的最大容量：CAPACITY中的前三位用作符号位，也就是说事情线程的最大容量为(2^29)-1

四种模子

CachedThreadPool：一个可缓存的线程池，假如线程池的当前局限高出了处理惩罚需求时，那么将接纳空闲的线程，当需求增加时，则可以添加新的线程，线程池的局限不存在任何的限制。

FixedThreadPool：一个牢靠巨细的线程池，提交一个任务时就建设一个线程，直到到达线程池的最大数量，这时线程池的巨细将不再变革。

SingleThreadPool：一个单线程的线程池，它只有一个事情线程来执行任务，可以确保凭据任务在行列中的顺序来串行执行，假如这个线程异常竣事将建设一个新的线程来执行任务。

ScheduledThreadPool：一个牢靠巨细的线程池，而且以延迟可能按时的方法来执行任务，雷同于Timer。

执行任务 execute

焦点逻辑：

1. 当前线程数量 < corePoolSize，直接开启新的焦点线程执行任务addWorker(command, true)
2. 当前线程数量 >= corePoolSize，且任务插手事情行列乐成

查抄线程池当前状态是否处于RUNNING

假如否，则拒绝该任务

假如是，判定当前线程数量是否为 0，假如为 0，就增加一个事情线程。

3. 开启普通线程执行任务addWorker(command, false)，劳务派遣管理系统，开启失败就拒绝该任务

从上面的阐明可以总结出线程池运行的四个阶段：

1. poolSize < corePoolSize 且行列为空，此时会新建线程来处理惩罚提交的任务
2. poolSize == corePoolSize，此时提交的任务进入事情行列，事情线程从行列中获取任务执行，昆山软件开发，此时行列不为空且未满。
3. poolSize == corePoolSize，而且行列已满，此时也会新建线程来处理惩罚提交的任务，可是poolSize < maxPoolSize
4. poolSize == maxPoolSize，而且行列已满，此时会触发拒绝计策

拒绝计策

前面我们提到任务无法执行会被拒绝，RejectedExecutionHandler是处理惩罚被拒绝任务的接口。下面是四种拒绝计策。

AbortPolicy：默认计策，终止任务，抛出RejectedException

CallerRunsPolicy：在挪用者线程执行当前任务，不抛异常

DiscardPolicy： 丢弃计策，直接扬弃任务，不抛异常

DiscardOldersPolicy：丢弃最老的任务，执行当前任务，不抛异常

线程池中的 Worker

Worker担任了AbstractQueuedSynchronizer和Runnable，前者给Worker提供锁的成果，后者执行事情线程的主要要领runWorker(Worker w)（从任务行列捞任务执行）。Worker 引用存在workers荟萃内里，用mainLock守护。

private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet<Worker> workers = new HashSet<Worker>();

焦点函数 runWorker

下面是简化的逻辑，留意：每个事情线程的run都执行下面的函数

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    while (task != null || (task = getTask()) != null) {
        w.lock();
        beforeExecute(wt, task);
        task.run();
        afterExecute(task, thrown);
        w.unlock();
    }
    processWorkerExit(w, completedAbruptly);
}

1. 从getTask()中获取任务
2. 锁住 worker
3. 执行beforeExecute(wt, task)，这是ThreadPoolExecutor提供应子类的扩展要领
4. 运行任务，假如该worker有设置了首次任务，则先执行首次任务且只执行一次。
5. 执行afterExecute(task, thrown);
6. 解锁 worker
7. 假如获取到的任务为 null，封锁 worker

获取任务 getTask

线程池内部的任务行列是一个阻塞行列，详细实此刻结构时传入。

private final BlockingQueue<Runnable> workQueue;