《一》前言
多线程的异步执行方式，虽然能够最大限度发挥多核计算机的计算能力，但是如果不加控制，反而会对系统造成负担。线程本身也要占用内存空间，大量的线程会占用内存资源并且可能会导致Out of Memory。即便没有这样的情况，大量的线程回收也会给GC带来很大的压力。
为了避免重复的创建线程，线程池的出现可以让线程进行复用。通俗点讲，当有工作来，就会向线程池拿一个线程，当工作完成后，并不是直接关闭线程，而是将这个线程归还给线程池供其他任务使用。这就是线程池的由来！
《二》Java通过ThreadPoolExecutor来创建线程池：
ThreadPoolExecutor th = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler)；
我们可以看到它里面的参数还是挺多的，下面来一一介绍：
1.corePoolSize：核心线程数，在创建线程池之后，它是默认没有线程在里面的。只有当任务来的时候才会去创建线程执行任务。那么就存在一个问题，当任务量达到这个核心线程树后再进来任务，该如何呢？答案是进队列，也就是说corePoolSize是允许同时运行的最大线程数。
2.maximumPoolSize：线程池最大的线程数，它表示能创建最大的线程数，maximumPoolSize >= corePoolSize。
3.keepAliveTime：线程没有任务时最多保持多久停止。默认的情况下，只有当达到corePoolSize时才会触发keepAliveTime，也就是说任务达到了corePoolSize后有空闲线程并且达到了keepAliveTime，那就讲这个线程shutdown。
4.unit：keepAliveTime 的单位。
5.workQueue：一个阻塞队列，用来存储等待执行的任务，当线程池中的线程数超过它的corePoolSize的时候，线程会进入阻塞队列进行阻塞等待。通过workQueue，线程池实现了阻塞功能。
6.threadFactory：创建线程工厂。
7.handler：当任务达到maximumPoolSize+workQueue，任务交给它处理。即表示当拒绝处理任务时的策略。
《三》这个队列具体用的什么队列呢？
任务缓存队列：
workQueue的类型为BlockingQueue<Runnable>，通常可以取下面三种类型：
1有界任务队列ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
2无界任务队列LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
3直接提交队列synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
《四》拒绝策略：（handler）
AbortPolicy:丢弃任务并抛出RejectedExecutionException
CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。
DiscardOldestPolicy：丢弃队列中最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务。
DiscardPolicy：丢弃任务，不做任何处理。
《五》线程池的任务处理策略：
如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。
《六》线程池的关闭：
ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：
shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务
《七》源码解析：
构造方法：
核心方法：public void execute(Runnable command)：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
// //继续3个步骤：
* 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.
//1.如果正在运行的线程数小于corePoolSize，那么将调用addWorker 方法来创建一个新的线
//程，
//并将该任务作为新线程的第一个任务来执行。在创建线程之前会做原子性质的检查，如果条件不允
//许，则不创建线程来执行任务，并返回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.
*
//2.如果一个任务成功进入阻塞队列，那么我们需要进行一个双重检查来确保是我们已经添加一个线
//程因为存在着一些线程在上次检查后他已经死亡。或者 当我们进入该方法时，该线程池已经关闭。所
//以，我们将重新检查状态，线程池关闭的情况下则回滚入队列，线程池没有线程的情况则创建一个新
//的线程。。
* 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.
*/
//3.如果我们无法排队任务，那么我们尝试添加一个新的*线程。如果失败，我们知道我们关闭或饱和
//因此拒绝任务。
// 1.当前线程数量小于corePoolSize，则创建并启动线程。
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
//成功
return;
c = ctl.get();
}
// 2.步骤1失败，则尝试进入阻塞队列，
if (isRunning(c) && workQueue.offer(command)) {
// 入队列成功，检查线程池状态，如果状态部署RUNNING而且remove成功，则拒绝任务
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
// 如果当前worker数量为0，通过addWorker(null, false)创建一个线程，其任务为null
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 3. 步骤1和2失败，则尝试将线程池的数量有corePoolSize扩充至maxPoolSize，如果失败，则
//拒绝任务
else if (!addWorker(command, false))
reject(command);
}
ThreadFactory:
addWorker方法：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 外层循环，用于判断线程池状态
// CAS+死循环实现的关于线程池状态，线程数量的校验与更新逻辑
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;
// 内层的循环，任务是将worker数量加1
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
}
}
// worker加1后，接下来将woker添加到HashSet<Worker>中，并启动worker
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//把指定任务作为参数新建一个worker线程
w = new Worker(firstTask);
//t就是代表woker线程
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();
}
// 如果往HashSet<Worker>添加成功，则启动该线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
《八》 Java通过Executors，提供了四种线程池：
1.创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
2.创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。阻塞队列使用的是LinkedBlockingQueue,若有多余的任务提交到线程池中，则会被暂存到阻塞队列，待空闲时再去执行。按照先入先出的顺序执行任务。
3.创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。它的缓存时间默认为60秒，核心线程是Integer.MAX_VALUE，阻塞队列用的是SynchronousQueue<Runnable>()，当线程空闲没有任务时，超过60秒就会关闭这个线程并回收。
4.创建一个定长线程池，支持定时及周期性任务执行。
