一. 线程池基础
1. 线程池的作用主要有三个：
（1）可以用来复用线程，降低因为频繁的创建和销毁线程的消耗；
（2）可以有效地控制线程的最大并发数；
（3）可以对线程进行一些简单的管理，如延时执行等。
2. 构造参数：
ThreadPoolExecutor是其核心类，public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler);其构造参数包括以下7项：
（1）corePoolSize：核心池大小：除非调用prestartAllCoreThreads()或prestartCoreThread()方法，否则在创建线程池后池中初始线程数为0，当池中线程数大于corePoolSize时，就会把新到的任务放到缓存队列中。
（2）maximumPoolSize：最大线程数
（3）keepAliveTime：当线程池中的线程数大于corePoolSize时，如果一个线程的空闲时间大于keepAliveTime,那么该线程就会终止。
（4）unit:参数keepAliveTime的时间单位,如TimeUnit.DAYS;
（5）workQueue：一个阻塞队列，用来存储等待执行的任务
（6）threadFactory：线程工厂，主要用来创建线程；
（7）handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
3.ExecutorService中有几个关键方法：
execute(): 用来执行方法；
submit(): 和execute()类似，区别在于他有返回值；
shutDown(),shutDownNow()用来关闭线程池。
二. 线程池原理
1. 线程池状态
在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：
volatile int runState;
static final int RUNNING = 0;
static final int SHUTDOWN = 1;
static final int STOP = 2;
static final int TERMINATED = 3;
当创建线程池后，初始时，线程池处于RUNNING状态；
如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。
2. 任务的执行原理
ThreadPoolExecutor类中其他的一些比较重要成员变量：
private final BlockingQueue<Runnable> workQueue; //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock(); //线程池的主要状态锁，对线程池状态（比如线程池大小,runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>(); //用来存放工作集
private volatile long keepAliveTime; //线程存货时间
private volatile boolean allowCoreThreadTimeOut; //是否允许为核心线程设置存活时间
private volatile int corePoolSize; //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int maximumPoolSize; //线程池最大能容忍的线程数
private volatile int poolSize; //线程池中当前的线程数
private volatile RejectedExecutionHandler handler; //任务拒绝策略
private volatile ThreadFactory threadFactory; //线程工厂，用来创建线程
private int largestPoolSize; //用来记录线程池中曾经出现过的最大线程数
private long completedTaskCount; //用来记录已经执行完毕的任务个数
而corePoolSize和largestPoolSize的区别就在于：
corePoolSize是平时线程的数量，但如果任务数目增长过快，那么可能会新增几个线程来进行补救，而新增之后总线程数不超过largestPoolSize，所以maximumPoolSize可以说是是线程池的一种补救措施，即任务量突然过大时的一种补救措施，但是要注意二者（核心现场和非核心线程）仅仅是一种分类方式或者说为了提供更加精密的控制，他们本质上是没有区别的。
在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，实现方式如下：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);//保证队列中的任务得到处理
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
其中，addIfUnderCorePoolSize()方法会尝试运行command，如果运行成功（条件是poolSize < corePoolSize && runState == RUNNING）那么poolSize会加一并返回true，如果运行失败则返回false。addIfUnderMaximumPoolSize()和addIfUnderCorePoolSize（）类似，区别就在于把corePoolSize（）换成maximumSize（）；
所以execute（）方法的执行过程就是若poolSize<corePoolSize就尝试新起一个线程来运行任务，否则会尝试将其加入缓存队列，如缓存队列已经超了，那就会再起线程来运行它，如果poolSize>maximumPoolSize，那就会启用拒绝策略来丢弃一些任务。
三. 四种常见的线程池
1. CachedThreadPool()
可缓存线程池：
（1）线程数无限制
（2）有空闲线程则复用空闲线程，若无空闲线程则新建线程
（3）一定程度减少频繁创建/销毁线程，减少系统开销
创建方法：
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
源码：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
2. FixedThreadPool()
定长线程池：
（1）可控制线程最大并发数（同时执行的线程数）
（2）超出的线程会在队列中等待
创建方法：
//nThreads => 最大线程数即maximumPoolSize
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads);
或
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);
源码：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
3.ScheduledThreadPool()
定长线程池：
（1）支持定时及周期性任务执行。
创建方法：
//nThreads => 最大线程数即maximumPoolSize
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);
源码：public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
4.SingleThreadExecutor()
单线程化的线程池：
（1）有且仅有一个工作线程执行任务
（2）所有任务按照指定顺序执行，即遵循队列的入队出队规则
创建方法：
ExecutorService singleThreadPool = Executors.newSingleThreadPool();
源码：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}
还有一个Executors.newSingleThreadScheduledExecutor()结合了3和4，就不介绍了，基本不用。
四.常用的workQueue类型：
（1）SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
（2）LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
（3）ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
（4）DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
参考：
