多线程（五）：线程池
一、网摘
程序的运行，其本质上，是对系统资源(CPU、内存、磁盘、网络等等)的使用。如何高效的使用这些资源是编程优化演进的一个方向。线程池就是一种对提高系统资源利用的优化手段。
在多个线程并发处理任务的情况下，如果每个线程只是执行一个时间很短的任务就结束，那么线程的创建和销毁会占用相当一部分系统资源。线程池就是在池中创建多个活跃的线程，当任务到来时，就分配若干线程去执行任务，任务执行完之后，线程不会销毁，而是放回到线程池中，等待执行新的任务。这样就避免了线程频繁的创建和销毁。
参考博客：
https://www.cnblogs.com/rinack/p/9888717.html
https://www.cnblogs.com/dolphin0520/p/3932921.html
二、ThreadPoolExecutor
用于线程池创建的类为ThreadPoolExecutor，线程池具备何种功能/属性与构建线程池时传入的参数相关。在工厂类Executors中，有已经设计好的线程池，可以直接拿来使用。JDK推荐使用Executors工厂类来创建线程池（programmers are urged to use the more convenient {@link Executors} factory methods），但是如果要根据实际情况来自己设计线程池的话，还是要用ThreadPoolExecutor。
下面即从ThreadPoolExecutor入手来学习线程池。
类继承关系
ThreadPoolExecutor继承自抽象类AbstractExecutorService。
AbstractExecutorService实现自ExecutorService接口中的方法
ExecutorService接口继承Executor，Executor是An object that executes submitted {@link Runnable} tasks.（一个用来执行提交的任务的类），里面只有一个方法execute(Runnable)，execute()是一个关键方法，用来执行线程任务。
文档说明
mark部分JDK文档中对ThreadPoolExecutor类的说明。
-corePoolSize & maximumPoolSize：
当一个新任务（Runnable target）被execute()方法提交执行，有以下两种情况：
如果线程数小于核心池(corePoolSize )大小，将会创建一个新线程来执行任务，即便其他线程处于空闲状态。
如果线程数大于核心池大小，但小于线程池最大容量(maximumPoolSize)，只有当任务队列已经满员的时候才会创建新线程，否则存入队列等待执行。
如果corePoolSize和maximumPoolSize相同，就得到一个fixed-size thread pool。
-On-demand construction：按需构建
默认情况下，只有当任务到来，才会执行线程的创建和启动。但prestartCoreThread()和prestartAllCoreThreads()允许在构建线程池之初创建好线程。
-ThreadFacotry
ThreadFactory用于创建线程，默认情况下使用defaultThreadFactory来创建线程，所创建的线程都在同一ThreadGroup中，并且具有相同的优先级，均为no-daemon线程。
-Keep-alive times
如果当前线程池线程数多于corePoolSize，则超过corePoolSize线程数的线程空闲时间超过Keep-alive times就会被停止。如果为0，线程将一直存在。
默认情况下，Keep-alive times仅适用于多于corePoolSize的线程，allowCoreThreadTimeOut(boolean)方法可让keep-alive适用于包括core线程在内的所有线程。即所有线程只要空闲一定时间就会被终结。
-Queuing 队列
BlockingQueue被用于转换（transfer）或持有（hold）任务。源码中的transfer，参考SynchronousQueue，自己的理解其实是传递，SynchronousQueue只是一个中转，到达一个任务就把任务交给一个线程，本身不存储任务。
一般情况下，当新任务到来时，如果线程数小于corePoolSize，将会创建新线程，而非存入队列。
如果corePoolSize或大于corePoolSize的线程在运行，将会存入队列而非创建新线程。
如果任务不能被存入队列（队列已满或其他原因），将会创建一个新线程。但是，如果当前线程数已经达到maximumPoolSize，并且队列已满，这个任务会被拒绝。
队列的三种策略（strategies）：
- Direct handoffs - SynchronousQueue
- Unbounded queues - LinkedBlockingQueue
- Bounded queues - ArrayBlockingQueue
Direct handoffs：
直接传递：SynchronousQueue，直接将任务传递给线程而不是持有（hold）他们，所以SynchronousQueue的大小永远为0。这种策略下，线程数会一直增长，如果当前没有线程可用，试图queue一个任务将会失败。所以Direct handoffs策略要求maximumPoolSizes为无限大（unbounded），这样才能避免拒绝一个任务。但maximumPoolSizes无限大，当任务到来时直接创建线程。当任务到达的平均速度比它们被处理的速度还要快时，就有可能出现无限的线程增长。
Unbounded queues：
无限大的队列：LinkedBlockingQueue，队列无限大，这样当任务到来时，如果核心线程数未达到corePoolSize，创建新线程，如果已经达到corePoolSize，任务会存入队列。此后线程数不会再增长，只会将任务一直存到这个无限大的队列中，也就是线程池最大线程数就是corePoolSize，maximumPoolSize无效。
这种策略适用于，传递的多个任务（tasks）之间是独立的、相互不影响的，适用于处理多个执行时间短、数量庞大的任务，当任务到达的平均速度比它们被处理的速度还要快时，就有可能出现队列无线的增长。
Bounded queues：
有限队列：ArrayBlockingQueue，当任务到来时，如果未达到corePoolSize，线程数增长；已达到corePoolSize未达到maximumPoolSize，存入任务队列，如果线程数已达到最大，且任务队列已满，拒绝新到来的任务。
有限队列配合合适大小的maximumPoolSize，使用容量大的队列(queue)和小的maximumPoolSize会使cpu消耗、系统资源(OS Resource)达到最小，但是可能会导致任务处理效率低(low throughput)；使用较小队列需要较大的maximumPoolSize，这样能够充分利用CPU，但也许会导致无法接受的调度消耗（encounter unacceptable scheduling overhead），这样同样会降低任务处理效率。
-Rejected tasks 任务拒绝
当线程池已关闭，或是线程数已达maximumPoolSize、队列已满，execute()提交的任务会被拒绝。四种任务拒绝策略：
- AbortPolicy，默认策略，任务被拒绝抛出RejectedExecutionException异常
- CallerRunsPolicy，由execute()的caller线程执行此任务
- DiscardPolicy，任务直接被丢弃，不会抛出异常
- DiscardOldestPolicy：队列最前面的任务被丢弃，新的任务存入队列，如果有多个任务需要拒绝，重复此
这样洋洋洒洒看下来，线程池这一块还蛮复杂，所以JAVA开发者开发了Executors类，定义好了一些适用于大多数情况的连接池，让我们可以直接拿来使用，如此在使用线程池时，就不用自己费心去设计、考虑以上那些内容了。所以JAVA的优势不仅在于语法简单，更重要的是，其内部还为我们默默实现了很多内容，这些内容不只是语法上的，比如指针，还包括开发者需求方面，就比如Executors直接创建线程池。
构造方法
ThreadPoolExecutor类中共有四个构造方法，传入的参数有所差别，以下列举其中一个构造方法。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
} 参数说明：
- corePoolSize，核心池大小，可以直接理解为线程池大小
- maximumPoolSize，线程池最大容量
- keepAliveTime，线程空闲状态下的存活时间，默认线程数大于corePoolSize小于maximumPoolSize生效
- TimeUnit 时间单位
- BlockingQueue
workQueue，任务队列 - ThreadFactory threadFactory，线程工厂
- RejectedExecutionHandler handler，拒绝任务处理策略
ThreadPoolExecutor的使用
public class TestPool {
public static void main(String[] args) {
// corePoolSize:5；maximumPoolSize:10；有限队列ArrayBlockingQueue
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(5));
for (int i = 0; i < 15; i++) {
Task task = new Task(i);
executor.execute(task);
System.out.println("线程数目：" + executor.getPoolSize() + "队列大小：" + executor.getQueue().size());
}
executor.shutdown();
}
static class Task implements Runnable {
private int taskNum;
public Task(int taskNum) {
this.taskNum = taskNum;
}
@Override
public void run() {
System.out.println("第-" + taskNum + "-个task正在运行");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("第-" + taskNum + "-个task停止运行");
}
public int getTaskNum() {
return taskNum;
}
public void setTaskNum(int taskNum) {
this.taskNum = taskNum;
}
}
}在用构造器构建好线程池之后，还是可以对线程池参数进行调整，如以下这些方法：
Executors构建线程池
首先需要指出的一点是，用Executors构建的线程池，其参数是不可再调整的，因为Executors提供的线程池构建方法，返回的都是ExecutorService的实例，ExecutorService中并没有修改线程池的方法。
-CachedThreadPool：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
} 按需构建线程的线程池，maximumPoolSize为无限大，时间单位为秒，移除空闲时间超过60秒的线程，使用的work queue为SynchronousQueue。
CachedThreadPool适用于处理生命周期短(short-lived)、异步的任务。而且能够保证线程的重用(reuse)：如果线程池存在空闲的线程，将会利用这些线程而不是新建线程。
-FixedThreadPool：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
} 固定大小的线程池，corePoolSize和maximumPoolSize相同，可以指定线程数nThreads，keep alive times为0，即创建的线程会一直存在，使用无线队列LinkedBlockingQueue。FixedThreadPool中最多只能存在nThreads个线程，多余的任务会在队列中存储。
-ScheduledThreadPool：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
newScheduledThreadPool()返回的是ScheduledExecutorService，ScheduledExecutorService继承自ExecutorService，额外提供了schedule(Runnable command,long delay, TimeUnit unit)等方法，能够定时执行任务。
-SingleThreadExecutor：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
} 只有一个线程，任务队列为无限大。