线程池介绍及创建线程池的4种方式
1. 什么是线程池
Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序
都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。
第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用
线程池，必须对其实现原理了如指掌。
java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
一个线程池包括以下四个基本组成部分：
1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。
2.线程池作用
线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。
如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。
3.线程池四种创建方式
Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：
ScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
FixedThreadPool ：
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
SingleThreadExecutor：
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
CachedThreadPool：
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4.案例演示:
newCachedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：
package com.company.emple4;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author shkstart
* @date 2019/6/10- 16:16
*/
public class Test001 {
public static void main(String[] args) {
//1.创建可缓存的线程池，可重复利用
ExecutorService newExecutorService = Executors.newCachedThreadPool();
//创建了10个线程
for (int i = 0; i < 10; i++) {
int temp = i;
newExecutorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
}
});
}
}
}
可以看到本来创建了10个线程池，这里只用了7个，因为newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
package com.company.emple4;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author shkstart
* @date 2019/6/10- 16:16
*/
public class Test001 {
public static void main(String[] args) {
//1.创建可固定长度的线程池
ExecutorService newExecutorService = Executors.newFixedThreadPool(3);
//创建了10个线程
for (int i = 0; i < 10; i++) {
int temp = i;
newExecutorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("threadName;"+Thread.currentThread().getName()+",i"+temp);
}
});
}
}
}
可以看到newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
package com.company.emple4;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import static java.util.concurrent.TimeUnit.*;
/**
* @author shkstart
* @date 2019/6/10- 16:16
*/
public class Test001 {
public static void main(String[] args) {
//1.创建可定时线程池
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 10; i++) {
final int temp = i;
newScheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("i:" + temp);
}
}, 3, TimeUnit.SECONDS);
}
}
}
表示延迟3秒执行。
newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：
package com.company.emple4;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import static java.util.concurrent.TimeUnit.*;
/**
* @author shkstart
* @date 2019/6/10- 16:16
*/
public class Test001 {
public static void main(String[] args) {
//1.创建单线程
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
newSingleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println("index:" + index);
try {
Thread.sleep(200);
} catch (Exception e) {
// TODO: handle exception
}
}
});
}
newSingleThreadExecutor.shutdown();
}
}
注意: 结果依次输出，相当于顺序执行各个任务。当shutdown时停止线程
5 为什么不建议使用 Executors静态工厂构建线程池
阿里巴巴Java开发手册，明确指出不允许使用Executors静态工厂构建线程池
原因如下：
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险
说明：Executors返回的线程池对象的弊端如下：
1：FixedThreadPool 和 SingleThreadPool：
允许的请求队列（底层实现是LinkedBlockingQueue）长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM
2：CachedThreadPool 和 ScheduledThreadPool
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
6.线程池大小与前四个参数
java有预置线程池：newSingleThreadExecutor，newFixedThreadPool，newCacheedThreadPool，newScheduledThreadPool，newWorkStealingPool。如果不适合，还可以使用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,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
我们接下来介绍参数，其中线程池大小与前四个参数有关。
corePoolSize： 核心线程数，会一直存在，除非allowCoreThreadTimeOut设置为true
刚创建线程池，没有，即不会预先创建。当任务到来，且当前线程没有超过corePoolSize，就会创建一个新线程执行该任务，即使其他线程是空闲。
不会因为空闲而被释放，keepAliveTime不适用。
maximumPoolSize：线程池允许的最大线程池数量。如上面情况，如果当前线程超过corePoolSize，先尝试排队，如果队列满了或者其他情况不能入队，那么它不会排队，而是检查线程数是否达到maximumPoolSize，如果没有，就创建线程，直到线程数达到maximumPoolSize。
keepAliveTime：空闲线程存活时间，线程数量超过corePoolSize，空闲线程的最大超时时间。当线程池的线程数大于corePoolSize，额外空闲线程的存活时间。如果到了时间，还没有新任务，就会释放线程。值为0，表示线程不会超时释放。
unit：超时时间的单位
workQueue：工作队列，保存未执行的Runnable 任务
threadFactory：创建线程的工厂类
handler：当线程已满，工作队列也满了的时候，会被调用。被用来实现各种拒绝策略。
BlockingQueue：阻塞队列。可以使用LinkedBlockingQueue（默认无界）、ArrayBlockingQueue、PriorityBlockingQueue（无界）、SynchronousQueue（没实际存储空间）。使用无界队列，需要注意，线程数最多达到corePoolSize，新任务来只能排队，maximumPoolSize没意义。SynchronousQueue只有正好有空闲线程，才会入队成功，否则总是创建新线程，直到达到maximumPoolSize。
handler：任务拒绝策略。有界队列，线程数达到maximumPoolSize，队列满了，触发任务拒绝策略。四种处理方式：AbortPolicy（默认，抛出异常），DiscardPolicy（忽略新任务，不抛异常），DiscardOldestPolicy（扔掉等待时间最长，自己排队），CallerRunsPolicy（任务提交者线程执行任务）
最佳自定义创建线程池，队列有界，maximumPoolSize有限，使用任务拒绝策略。如果队列无界，服务不了的任务总是会排队，消耗内存，甚至引发内存不足异常。如果队列有界但maximumPoolSize无线，可能会创建过多线程，占内存和CPU。
1.如果当前线程池中的线程数目小于corePoolSize，则每来一个任务就会去创建一个线程去执行。
2.如果当前线程池中线程数大于corePoolSize，则每来一个任务就会添加到缓存队列。
3.添加成功，则该任务会等待空闲线程将其取出执行。若添加失败，则会创建新的线程进行执行。
4.如果队列已满，则在总线程数小于maximumPoolSize的前提下，则创建新的线程。
5.如果当前线程池中的线程数达到了maximunPoolSize，则再来新的任务，则执行拒绝策略。
6.如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。
---------------------------------------------------
