概念：线程池顾名思义是存放线程的池子，意思是当程序需要用到线程的时候，就从线程池中取出线程，用完之后就可以将线程放回线程池中去。
7.1线程池相关概念
7.1.1 线程池数量
Question1：线程池中的线程数量是不是越多越好呢？答案当然是否定的！
1、线程是一个对象，也是操作系统的资源，线程创建、销毁需要实现。如果创建时间+销毁时间 > 执行任务时间，这样创建线程就很划不来了。
2、创建线程需要占用堆内存，操作系统线程占用系统内存，根据JVM规范，一个线程默认最大栈大小是1M，这个栈空间是需要从系统内存中分配的，线程过多，也会消耗很多系统内存。
3、操作系统需要频繁切换线程上下文（各个线程都会去争抢CPU的执行时间），这样也很影响性能。
Question2：线程池的数量是多少合适？
计算型任务：CPU数量的1-2倍
IO型任务：要根据具体的IO阻塞时长进行考量决定，如tomcat中默认的最大线程数：200。也可以根据需要在一个最小数量和最大数量间自动增减线程数。（可以监控CPU的情况来确定，一般来说CPU占用达到80%就差不多了）
7.1.2 线程池相关概念
线程池管理器：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务
工作线程：线程池中线程在没有任务时处于等待状态，可以循环的执行任务。
任务接口：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等。
任务队列：用于存放没有处理的任务，提供一种缓冲机制。
好比图中的这个例子，有很多的任务，但是执行任务的人只有4个，也就是工作线程数只有4个，但是队列可以先缓存任务，等这些在执行任务的人执行完了他当前的任务之后，他再从队列中继续拿任务过来执行。
7.1.3 线程池API
7.1.3.1 接口定义和实现类
7.1.3.2 方法定义
ExecutorService的方法定义：
ScheduledExecutorService的方法定义：
7.1.3.3 Executor工具类
JDK中提供了三种线程池的工厂类：
1）newFixedThreadPool(int nThreads)：创建一个固定大小、任务队列无界的线程池。核心线程数等于最大线程池数。
2）newCachedThreadPool()：创建一个大小无界的缓冲线程池，它的任务队列是一个同步队列，任务加入到池中，如果池中有空闲线程，则用空闲线程执行，如无则创建新线程执行，池中的线程空闲时间超过60秒，将被销毁释放，线程数随任务的多少变化，适用于执行耗时小的异步任务。核心线程数为0，最大线程数为Integer.MAX_VALUE。
3）newSingleThreadExecutor()：只有一个线程来执行无界任务队列的单一线程池，该线程池确保任务按加入的顺序一个一个依次执行。当唯一的线程因任务异常终止时，将创建一个新的线程来继续执行后续的任务，与newFixedThreadPool(1)的区别在于，单一线程池的池大小在newSingleThreadExcutor方法中硬编码不能再改变了。
7.1.3.4 任务execute过程
7.2 ThreadPoolExecutor实例
下面将进行几个测试，测试核心线程池、最大线程池、任务队列、超过核心线程数量的线程存活时间等。
7.2.1 任务队列无界
ThreadPoolDemo1：
/**
* @Author: Vander
* @Date: 2019/3/26
* @Description: 线程池信息： 核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
*/
public class ThreadPoolDemo1 {
/**
* 使用无界队列
*
* @throws Exception
*/
public static ThreadPoolExecutor threadPoolExecutor() throws Exception {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(), threadFactory());
// 预计结果：线程池线程数量为：5,超出数量的任务，其他的进入队列中等待被执行
return threadPoolExecutor;
}
public static ThreadFactory threadFactory() {
ThreadFactory factory = r -> {
Thread thread = new Thread(r);
String threadName = String.format("ThreadGroup:%s-threadId:%s", thread.getThreadGroup().getName(), thread.getId());
thread.setName(threadName);
return thread;
};
return factory;
}
}
Main：
public class Main {
public static void main(String args[]) throws Exception {
testCommon(ThreadPoolDemo1.threadPoolExecutor());
}
/**
* 测试： 提交15个执行时间需要3秒的任务,看线程池的状况
*
* @param threadPoolExecutor 传入不同的线程池，看不同的结果
* @throws Exception
*/
public static void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
for (int i = 0; i < 15; i++) {
int n = i;
threadPoolExecutor.submit(() -> {
try {
System.out.println("开始执行：" + n);
Thread.sleep(3000L);
System.err.println("执行结束:" + n);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("任务提交成功 :" + i);
}
// 查看线程数量，查看队列等待数量
Thread.sleep(500L);
System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
// 等待15秒，查看线程数量和队列数量（理论上，超出核心线程数量的线程会被自动销毁）
Thread.sleep(15000L);
System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize());
System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size());
}
}
使用无界队列的结果是任务都被缓存起来了，任务创建起来之后会被放到无界队列中等待执行，由于无界队列不会满，所以最大线程数设置了也不起作用。
7.2.2 任务队列有界，并设置拒绝任务策略
/**
* @Author: Vander
* @Date: 2019/3/26
* @Description: 线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
*/
public class ThreadPoolDemo2 {
/**
*
* @throws Exception
*/
public static ThreadPoolExecutor threadPoolExecutor() throws Exception {
// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3的线程池，也就是最大容纳13个任务。
// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(3), new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.err.println("有任务被拒绝执行了");
}
});
return threadPoolExecutor;
// 预计结果：
// 1、 5个任务直接分配线程开始执行
// 2、 3个任务进入等待队列
// 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁)
// 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。
// 5、 任务执行，5秒后，如果无任务可执行，销毁临时创建的5个线程
}
}
执行的结果可以看到“有任务被拒绝执行”。
7.2.3 使用无界的同步队列
SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。
在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时，而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务，那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize）。
简单的说，由于同步队列不缓存任务，所以它一拿到任务就会丢给线程池去处理，线程池中如果有空闲线程，空闲线程就会去处理该任务，若没有空闲线程，则创建新的线程去处理。
在实际应用中不建议直接将任务的最大值设置为Integer的最大值，可以控制一下它最大值才使用它。
/**
* @Author: Vander
* @Date: 2019/3/26
* @Description:
*/
public class ThreadPoolDemo3 {
/**
* 3、 线程池信息：
* 核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列，超出核心线程数量的线程存活时间：60秒
*
* @throws Exception
*/
public static ThreadPoolExecutor threadPoolExecutor() throws Exception {
// SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。
// 在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时，
// 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务，
// 那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。
// 此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize）。
// 和Executors.newCachedThreadPool()一样的
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
new SynchronousQueue<>());
// 预计结果：
// 1、 线程池线程数量为：15，超出数量的任务，其他的进入队列中等待被执行
// 2、 所有任务执行结束，60秒后，如果无任务可执行，所有线程全部被销毁，池的大小恢复为0
return threadPoolExecutor;
}
}
预计结果：
1、线程池线程数量为：15，超出数量的任务，其他的进入队列中等待被执行
2、所有任务执行结束，60秒后，如果无任务可执行，所有线程全部被销毁，池的大小恢复为0。
7.2.4 线程池终止的方式（shutdown和shutdownNow）
线程池终止线程执行的方式有两种：
1、shutdown
2、shutdownNow
7.2.4.1 shutdown
/**
* @Auther: Vander
* @Date: 2019/3/26
* @Description: 测试终止线程池的shutdown方法
*/
public class ThreadPoolDemo7 {
/**
* 7、 终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
*
* @throws Exception
*/
private void threadPoolExecutorTest7() throws Exception {
// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.err.println("有任务被拒绝执行了");
}
});
// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
for (int i = 0; i < 15; i++) {
int n = i;
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
try {
System.out.println("开始执行：" + n);
Thread.sleep(3000L);
System.err.println("执行结束:" + n);
} catch (InterruptedException e) {
System.out.println("异常：" + e.getMessage());
}
}
});
System.out.println("任务提交成功 :" + i);
}
// 1秒后终止线程池
Thread.sleep(1000L);
threadPoolExecutor.shutdown();
// 再次提交提示失败
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
System.out.println("追加一个任务");
}
});
}
}
结果分析
1、10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
2、调用shutdown后，不接收新的任务，等待13任务执行结束
3、追加的任务在线程池关闭后，无法再提交，会被拒绝执行
7.2.4.2 shutdownNow
/**
* @Auther: Vander
* @Date: 2019/3/26
* @Description: 立刻终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
*/
public class ShutdownNowDemo {
/**
*
* @throws Exception
*/
public static void threadPoolExecutor() throws Exception {
// 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。
// 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("有任务被拒绝执行了"));
// 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况
for (int i = 0; i < 15; i++) {
int n = i;
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
try {
System.out.println("开始执行：" + n);
Thread.sleep(3000L);
System.err.println("执行结束:" + n);
} catch (InterruptedException e) {
System.out.println("异常：" + e.getMessage());
}
}
});
System.out.println("任务提交成功 :" + i);
}
// 1秒后终止线程池
Thread.sleep(1000L);
List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow();
// 再次提交提示失败
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
System.out.println("追加一个任务");
}
});
System.out.println("未结束的任务有：" + shutdownNow.size());
}
}
结果分析：
1、10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行
2、调用shutdownnow后，队列中的3个线程不再执行，10个线程被终止
3、追加的任务在线程池关闭后，无法再提交，会被拒绝执行
7.3 ScheduledThreadPoolExecutor实例
7.3.1一次性的定时任务
/**
* @Auther: Vander
* @Date: 2019/3/26
* @Description: 定时执行线程池信息：3秒后执行，一次性任务，到点就执行
*/
public class ThreadPoolDemo1 {
/**
* 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒
*
* @throws Exception
*/
public static ThreadPoolExecutor threadPoolExecutor() throws Exception {
// 和Executors.newScheduledThreadPool()一样的
ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
threadPoolExecutor.schedule(() -> System.out.println("任务被执行，现在时间：" + System.currentTimeMillis()), 3000, TimeUnit.MILLISECONDS);
System.out.println(
"定时任务，提交成功，时间是：" + System.currentTimeMillis() + ", 当前线程池中线程数量：" + threadPoolExecutor.getPoolSize());
// 预计结果：任务在3秒后被执行一次
return threadPoolExecutor;
}
}
定时任务实现的本质是使用延迟队列，DelayedWorkQueue得等到时间到了才能从队列中取出任务，否则取不出来。
7.3.2 scheduleAtFixedRate和scheduledWithFixedDelay
不管是scheduleAtFixedRate和scheduledWithFixedDelay都不会并发执行线程，区别在于，假设当前线程要执行3秒，FixedRate、FixedDelay设置的是1秒，则FixedRate的线程会马上执行下一次任务，而FixedDelay会在上个线程执行完之后，重新计时，该线程要到第4秒才执行任务。
7.3.2.1 scheduleAtFixedRate示例
public class FixedRateDemo {
public static void main(String args[]){
testFixedRate();
}
public static void testFixedRate(){
ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
scheduledExecutorService.scheduleAtFixedRate(() -> {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
System.out.println(df.format(new Date()));// new Date()为获取当前系统时间
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, 0, 2, TimeUnit.SECONDS);
}
}
执行结果：
7.3.2.2 scheduledWithFixedDelay示例
public class FixedDelayDemo {
public static void main(String args[]){
testFixedDelay();
}
public static void testFixedDelay(){
ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
scheduledExecutorService.scheduleWithFixedDelay(() -> {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
System.out.println(df.format(new Date()));// new Date()为获取当前系统时间
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, 0, 2, TimeUnit.SECONDS);
}
}
执行结果：
