使用线程池的好处
引用自 http://ifeve.com/java-threadpool/ 的说明：
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
- 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
Java中的线程池是用ThreadPoolExecutor类来实现的. 本文就结合JDK 1.8对该类的源码来分析一下这个类内部对于线程的创建, 管理以及后台任务的调度等方面的执行原理。ThreadPoolExecutor结构如下图：
Executor接口
此接口提供了一种将任务提交与每个任务的运行机制分离的方法，包括线程使用，调度等的详细信息。该接口中只有execute(Runnable command)方法，用来替代通常创建或启动线程的方法。例如使用Thread创建线程
Thread thread = new Thread(); thread.start();
使用execute创建运行线程，具体的线程执行会由相应的实现类去执行（jdk默认线程池execute的实现是由ThreadPoolExecutor来实现的）
Thread thread = new Thread(); executor.execute(thread);
ExecutorService接口
ExecutorService接口提供管理终止的方法和可以生成Future的方法，用于跟踪一个或多个异步任务的进度， 它继承了Executor接口，同时增加了shutDown()，shutDownNow()，invokeAll()，invokeAny()和submit()等方法。
shutDown() ： 允许之前提交的任务继续执行（执行完后shutDown，不会再接收新的任务） shutDownNow()：立即停止正在执行的任务 invokeAll()：执行给定的任务，当所有任务完成后返回任务状态和结果的Futures列表
invokeAny()：执行给定的任务，返回已完成的任务的结果 submit()：提交线程
AbstractExecutorService类
ExecutorService接口的默认实现，同时也是线程池实现类ThreadPoolExecutor的父类，主要看下submit()方法与invokeAll()方法：
submit：
/**不管参数是Callable还是Runable, 执行方法都一样，生成一个task，然后执行task，execute方法的具体实现在ThreadPoolExecutor中，后续分析**/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
invokeAll ：
/**代码很简单，将给定的任务线程封装成Future对象，等待所有任务执行完成，统一返回Future对象，如果出现异常，会将未完成的任务取消**/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
execute(f);
}
for (int i = 0, size = futures.size(); i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
try {
/** 没有完成，阻塞**/
f.get();
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
if (!done)
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
ThreadPoolExecutor类
在关注ThreadPoolExecutor之前，先来了解下线程的基本状态信息。
线程总的来说有NEW(初始)、RUNNABLE（运行）、WAITING（等待）、TIME_WAITING（超时等待）、BLOCKED（阻塞）、TERMINATED（终止）6种状态。
NEW：初始状态，线程被构建，但是还没有调用 start 方法
RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中” BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况 等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中 其他阻塞：运行的线程执行 Thread.sleep 或者 Thread.join 方法，或者发出了 I/O请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、join 线程终止、
io 处理完毕则线程恢复
WAITING：等待，需要主动唤醒 TIME_WAITING：超时等待状态，超时以后自动返回. TERMINATED：终止状态，表示当前线程执行完毕
具体的转化关系如下图：
对于线程池而言，也有五种种不同的状态，分别为RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED
RUNNING：运行状态，可以处理任务，并且接收任务（前提阻塞队列处于未满状态，阻塞队列一旦满了，会根据相应的饱和策略进行不同的处理） SHUTDOWN：关闭状态，不能接收新的任务，但是能处理队列中的任务（shutdow方法） STOP：停止状态，不能接收行的任务，不能处理队列中的任务并且会中断正在运行的任务（shutdownNow方法） TIDYING：所有的任务都终止了，workCount为0，会进入该状态，将调用terminated方法进入TERMINATED状态 TERMINATED：terminated（）方法执行完成
各个状态之间的转化关系（借用这里的图）
ThreadPoolExcecutor类有一些重要的属性：
corePoolSize：线程池中核心线程的数量 maximumPoolSize：线程池中最大线程的数量 defaultHandler：默认的线程池饱和执行策略，一般是阻塞队列满了后且没有空闲线程，再有任务提交是抛出异常，还是直接丢弃等，默认的策略是抛出异：
ctl：对线程池运行状态以及线程池中有效线程数进行记录的一个原子性int变量，主要记录两部分：线程池中的有效线程（workerCount）;线程的状态（runstate）包含运行，shutdown
等状态。该变量的高3位用来记录runstate，低29位用来记录有效线程数（约5亿条）（其实这个地方与ReentReadWriteLock中的state变量相似）
COUNT_BITS：workerCount计数位数，低29位
CAPACITY：workerCount的最大值2^29 - 1
饱和策略（内部类）
ThreadPoolExecutor中提供了四种可选择的饱和策略（拒绝策略），用来处理阻塞队列已满且没有空闲线程，后续新来任务的处理
AbortPolicy：直接抛出异常（默认策略） CallerRunsPolicy：用调用者所在的线程执行任务 CallerRunsPolicy：丢弃队列中最靠前的任务，执行该任务 DiscardPolicy：直接丢弃
worker类（内部类）
worker类是实现线程池的重要类，它继承了AQS类并实现了Runnable接口，结构如下：
Worker内部类主要是用来将运行线程封装，维护运行任务线程中断状态的类，该类继承了AQS类并实现了Runnable接口
变量：
firstTask: 提交的任务线程； thread: worker类封装后的线程，用来处理任务线程； completeTasks: 完成的任务数；
构造方法：
Worker(Runnable firstTask) {
/**初始化锁的获取次数**/
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
获取锁、释放锁
从Worker类获取锁的方式可以看到worker类只会去获取独占锁，也就是说不支持重入的，这也是为什么Worker不直接使用ReentrantLock的原因，ReentrantLock是可重入的；当worker获取到锁时表明工作线程正在运行，不允许中断（可以在runWorker中查看）；
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
构造方法
ThreadPoolExecutor总共有四种构造方法
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
/**所有的构造方法调用的都是该方法**/
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;
}
字段说明：
corePoolSize:线程池初始化核心线程数
maximumPoolSize:线程池最大线程数
keepAliveTime:空闲线程存活时间
workQueue:存放任务的队列（阻塞队列）
threadFactory:线程池的类型
handler:饱和处理策略
线程池的执行流程
下图是个人理解的线程池执行的简单流程（有不对的地方烦请指正）
execute方法
执行给定的任务，可能是用的是新创建的线程，也可能是已存在的线程
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/**获取ctl，记录workCount以及runState, 为32**/
int c = ctl.get();
/**判断线程池中的线程数是否小于核心线程数**/
if (workerCountOf(c) < corePoolSize) {
/**添加一个工作线程线程**/
if (addWorker(command, true))
return;
/**添加失败重新获取ctl**/
c = ctl.get();
}
/**线程池是运行状态，并且线程成功添加到队列（线程池中线程数大于核心线程或者小于核心线程且添加线程失败）**/
if (isRunning(c) && workQueue.offer(command)) {
/**重新获取ctl**/
int recheck = ctl.get();
/**该处的二次检查是为了防止线程池被shutdown或者上次检查后有线程死亡**/
/**重新判断线程池是否是运行状态，如果不是运行状态，将成功添加到队列中的线程从队列中移除，同时通过对应的饱和策略处理**/
if (! isRunning(recheck) && remove(command))
/**执行拒绝策略**/
reject(command);
/**如果工作线程为0，执行添加工作线程操作**/
else if (workerCountOf(recheck) == 0)
/**添加一个工作线程但不启动**/
addWorker(null, false);
}
/** 执行到这里说有存在两种情况
* 1.线程池是running状态，工作线程数大于核心线程数且阻塞队列已满导致添加任务失败。
* 2.线程池不是工作状态
**/
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);
/** 判断是否需要添加新的线程（不在添加需要满足两个条件：rs >= shutdown; 第二个条件整体为false)
* 1.rs >= SHUTDOWN 即线程池是shutdown、stop、tidying、terminated状态，表示线程池不在接收新的任务。
*
* 2.rs == SHUTDOWN 即线程池不在接收新的任务；firstTask == null 即提交执行的线程为空；！workQueue.isEmpty() 即阻塞队列不为空只要三个条件有
* 一个不满足，则返回false。
* 2.1. 能执行到这里表名rs一定是>=SHUTDOWN的，如果rs不是SHUTDOWN状态，线程池不会接受新的任务，以及正在处理的任务一会停掉，所以不需要添加新的
* 工作线程。
* 2.2. fistTask为空，没必要为该任务创建新的工作线程
* 2.3. 阻塞队列为空，进行该判断表明rs = 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;
/**通过cas方法添加一个工作线程数**/
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 {
/**根据firstTask创建一个工作线程**/
w = new Worker(firstTask);
final Thread t = w.thread;
/**firstTask为null只创建，不启动**/
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());
/**1. 线程池是running状态
*2. 线程池是shutdown状态并且firstTask为null
*满足上面任意一个条件，会去添加工作线程，对于第二个条件来说，不会去接收新的任务，但阻塞队列可能没有处理完，可以添加新的工作线程
**/
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)
/**添加工作线程失败，进行回滚操作
*1.将添加的工作线程从工作线程集合中移除
*2.线程池工作线程数减一
*3.重新执行线程池的terminate状态转换
**/
addWorkerFailed(w);
}
return workerStarted;
}
runWorker方法（执行任务）
/**仅仅会在addWorker()成功时调用，内容比较简单，需要注意三个地方getTask()、beforeExecute()、afterExecute()（后两个可以自己重写）**/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
/** 释放锁，对应于worker类构造方法中的setState(-1), 将state状态恢复为0，允许中断
* 线程池正在初始化任务线程时，会将锁的初始值设置为-1，这样做的目的是禁止执行前对任务进行中断
**/
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
/**通过getTask（）方法获取任务**/
while (task != null || (task = getTask()) != null) {
w.lock();
/**判断线程/线程池是否处于中断/stop状态**/
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 {
/**释放锁，任务完成数加1**/
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
getTask方法
private Runnable getTask() {
/**从阻塞队列中获取任务是否超时的变量设置**/
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/**如果线程池不是运行状态
*1.线程是是否是stop、TIDYING、terminate状态
*2.阻塞队列是否为空
*满足以上条件 1||2，表明线程池不处理任务，不接受新的任务，线程池任务线程数-1
**/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
/**allowCoreThreadTimeOut为false表示线程池中核心线程数不需要进行超时判断**/
// 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;
}
/**获取任务（都会阻塞）
* 如果设置了核心线程运行超时，或者是线程池中任务线程数多于核心线程数，通过pool设置超时时间获取任务。
* 没事设置超时时间，通过take方法获取任务
**/
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
shutdownNow方法
与shutdown方法相比，多了一个drainQueue清空阻塞队列的方法，并且所有线程进行中断操作
/**shutdown方法主要调用了四个方法**/
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
/**如果存在安全管理器，判断是否有权限interrupt权限**/
checkShutdownAccess();
/**设置线程池运行状态**/
advanceRunState(STOP);
/**中断任务线程**/
interruptWorkers();
/**清空阻塞队列**/
tasks = drainQueue();
} finally {
mainLock.unlock();
}
/**尝试将线程池设置为terminate状态**/
tryTerminate();
return tasks;
}
/**该方法是worker类中的方法，直接中断，与shutdown方法相比，改方法是对所有的任务线程进行中断操作，
*shutdown方法会去先尝试获取锁，如果获取锁成功，表示当前线程正在等待任务，对于这种任务线程进行中断操作**/
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
tryTerminate方法
final void tryTerminate() {
for (;;) {
int c = ctl.get();
/**1.线程池是否是运行状态
*2.线程池是都是Tidying、terminate状态
*3.线程池是否是shutdown状态，并且阻塞队列不为空
*满足上述3个条件任意一个立即返回：
*运行状态，线程池允许任务的处理以及添加，不能直接转换到terminate
*shutdown状态，阻塞队列不为空，表示还在处理任务，不能直接转换到terminate
**/
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
/**线程池为shutdown或者stop状态，且阻塞队列为空
*如果线程池工作线程数不为0，至少中断一个工作线程, 此处可能存在getTask获取任务是一直处于阻塞的任务线程，避免队列为空，任务线程一直阻塞的情况
**/
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
/**设置为tidying状态**/
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
/**设置成terminated状态**/
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
线程池的监控
getPoolSize() : 获取当前线程池的工作线程数量 getQueue() : 获取线程池中阻塞队列（间接获取阻塞队列中任务的数量） getCompletedTaskCount() : 获取也完成的任务数量 getTaskCount() : 获取已运行、未运行的任务总数 getLargestPoolSize() ： 线程池线程数最大值 getActiveCount()：当前线程池中正在执行任务的线程数量。 getCorePoolSize() : 线程池核心线程数
常见的线程池（Executors）
Executors是线程池的工厂类，通过Executors可以创建四种不同的线程池 （newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor、newWorkStealingPool（也是一种线程池，但不是通过ThreadPoolExecutor实现，不做讨论））
阻塞队列（引用这里）
SynchronousQueue：newCachedThreadPool
LinkedBlockingQueue(无界队列)：基于链表的阻塞队列LinkedBlockingQueue。如果使用这种方式，那么线程池中能够创建的最大线程数就是corePoolSize，
而maximumPoolSize就不会起作用了（后面也会说到）。当线程池中所有的核心线程都是RUNNING状态时，这时一个新的任务提交就会放入等待队列中。
newFixedThreadPool使用
ArrayBlockingQueue(有界队列)：使用该方式可以将线程池的最大线程数量限制为maximumPoolSize，这样能够降低资源的消耗，但同时这种方式也使得线程池对线程的调度变
得更困难，因为线程池和队列的容量都是有限的值，所以要想使线程池处理任务的吞吐率达到一个相对合理的范围，又想使线程调度相对简单，并且还要尽可
能的降低线程池对资源的消耗，就需要合理的设置这两个数量。
1. 如果要想降低系统资源的消耗（包括CPU的使用率，操作系统资源的消耗，上下文环境切换的开销等）, 可以设置较大的队列容量和较小的线程池容量,
但这样也会降低线程处理任务的吞吐量。
2. 如果提交的任务经常发生阻塞，那么可以考虑通过调用 setMaximumPoolSize() 方法来重新设定线程池的容量。
3. 如果队列的容量设置的较小，通常需要将线程池的容量设置大一点，这样CPU的使用率会相对的高一些。但如果线程池的容量设置的过大，则在提交的任
务数量太多的情况下，并发量会增加，那么线程之间的调度就是一个要考虑的问题，因为这样反而有可能降低处理任务的吞吐量。
DelayedWorkQueue ： ScheduledThreadPoolExecutor使用
newFixedThreadPool
固定线程数量的线程池，corePoolSize==maximumPoolSize 1.所有工作线程都在执行任务，新来任务需要在队列中等待直到有空闲工作线程 2.工作线程在执行任务时被shutdown了，新来任务是会创建一个新的任务线程
newCachedThreadPool
可缓存线程池，corePoolSize==0, maximumPoolSize=Integer.MAX_VALUE 1.没有核心任务处理线程 2.新来任务是如果有空闲的处理线程，直接使用已有的处理线程，否则创建一个处理线程 3.当超过60s工作线程没有任务处理，将会被销毁 该线程池适合处理执行时间短，数量多的任务
newScheduledThreadPool
调度线程池，jdk中单独一个类实现，初始化对象时设置corePoolSize，maximumPoolSize=Integer.MAX_VALUE 用来设置给定延迟时间后执行
newSingleThreadExecutor
只有一个工作线程来处理任务的线程池，corePoolSize==maximumPoolSize==1