java核心-多线程（6）-线程池-ThreadPoolExecutor
1.java多线程编程少不了使用线程池，线程池相关的工具类所在jdk包，java.util.concurrent
2.使用示例
demo1
public class ThreadPoolDemo {
/*
本示例使用线程池实现两个线程交替打应数字，直到10
*/
private static Object obj1 = new Object();
private static int num = 0;
public static void main(String[] args){
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2, 10000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
//打印奇数线程
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
System.out.println("奇数run");
while (true){
synchronized (obj1){
if(num > 10){
break;
}
System.out.println("奇数抢到" + num);
if(num/2 != 0){
System.out.println("奇：" + num);
num++;
obj1.notifyAll();
}else{
try {
System.out.println("奇数线程等待");
obj1.wait(); //wait会让出锁；
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
});
//打印偶数线程
threadPoolExecutor.submit(new Runnable() {
@Override
public void run() {
System.out.println("偶数run");
while(true){
synchronized (obj1){
if(num > 10){
break;
}
System.out.println("偶数抢到" + num);
if(num/2 == 0){
System.out.println("偶：" + num);
num++;
obj1.notifyAll();
}else{
try {
System.out.println("偶数线程等待");
obj1.wait(); //wait会让出锁；
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
});
}
}
意外发生了，我发现我随手写的代码是垃圾，下面是运行结果
分析一下结果
前面是上班期间匆匆忙忙写的代码，周末回家定睛一看，代码中一个很低级的错，就是取余%符号写成了除号/，我实在很是无语，突然让我想起今日听到的一句话——“粗心大意是基本功不扎实的表现”，本想把前面的都删了，转念一想，干嘛呢？写这些不就是记录自己的学习过程的吗，这些错误会成为以后回忆这篇文字的hook，都记下来吧。
改正后运行效果，程序实现了两个线程交替打印0和1
3.ThreadPoolExecutor类分析
3.1.构造方法
前面例子中构造方法：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
显然最终构造方法是：
public ThreadPoolExecutor(int corePoolSize, //核心线程数
int maximumPoolSize, //最大线程数
long keepAliveTime, //线程存活时间
TimeUnit unit, //时间单位
BlockingQueue<Runnable> workQueue, //任务队列
ThreadFactory threadFactory, //线程工厂
RejectedExecutionHandler handler) //拒绝策略
解释
1.核心线程数：当提交新任务时，线程池中线程小于核心线程数，则会创建一个线程处理该新任务。
2.最大线程数：当提交新任务时，如果任务队列已满且线程数量小于最大线程数时，则会创建一个新线程处理该任务。
3.线程存活时间：线程池中线程数量大于核心线程数时，空闲时间超过该设定时间的线程被销毁。
4.时间单位：存活时间的单位
5.任务队列：当线程数量等于核心线程设定值时，新提交的任务会被放到任务队列中。任务队列有好几种，后面再细说。
6.线程工厂：用来创建线程，可以控制线程所属组合线程名，后面细说。
7.拒绝策略：当提交新任务时，任务队列已满且线程达到最大线程数，此时调用拒绝策略，后面再细说。
3.2.核心方法
3.3.线程池工作过程
<1>任务提交过程
submit()方法最终会调用execute()执行任务。execute()方法中多次调用addWorker方法，该方法的主要作用就是创建一个线程来执行Runnable对象。
execute()方法执行一个Runnable对象时，首先通过workerCountOf(c)获取线程池中线程的数量，如果池中的数量小于corePoolSize就调用addWorker添加一个线程来执行这个任务。否则通过workQueue.offer(command)方法入列。如果入列成功还需要在一次判断池中的线程数，因为我们创建线程池时可能要求核心线程数量为0，所以我们必须使用addWorker(null, false)来创建一个临时线程去阻塞队列中获取任务来执行。
提交时涉及构造方法中的四个参数corePoolSize、maxPoolSize、blockingQueue、rejectHandler。具体关系很好懂，结合前面参数理解，或者想象一下现实排队策略（正编员工，队列，临时工）就明白了。
<2>执行过程
Thread的run方法实际上调用了Worker类的runWorker方法。
Worker类是ThreadPoolExecutor类中私有类
private final class Worker
extends AbstractQueuedSynchronizer implements Runnable
<3>关闭过程
涉及shutdown()、shutdownNow()、awaitTermination(long timeout, TimeUnit unit)方法
之前自己工作遇到的一个停止demo如下：
threadPoolExecutor.shutdown(); //停止提交任务，执行完当前和队列中的任务(好比开始考试了，迟到的学生停止入场)
try {
if(!threadPoolExecutor.awaitTermination(120, TimeUnit.MINUTES)){ //120min过后检测是否停掉，中间即便早执行完，也不会返回(好比120分钟考试结束，判断是否所有学生都交卷)
System.out.println("规定时间内没有执行所有任务");
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
threadPoolExecutor.shutdownNow(); //最后再强行停止（好比，有些学生最后被老师强行收卷，但老师可能还干不过学生）
}
3.4.类结构关系
Executor类并不是线程池，而只是一个执行线程的工具，真正的线程池接口是ExecutorService；
ScheduledExecutorService, 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题；
ThreadPoolExecutor,线程池的真正实现；
ScheduledThreadPoolExecutor,周期性任务调度的类实现；
4.Executors类和各种线程池
要配置一个线程池是比较复杂的，尤其是对线程池的原理不是很清楚的情况下，很可能配置的线程池不是较优的，因此Executors类里面提供了一些静态工厂，生成一些常用的线程池。
1.newCachedThreadPool: 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，新建线程（线程最大并发数不可控制）。
使用场景：CachedThreadPool 用于并发执行“大量短期的小任务”，或者是负载较轻的服务器。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
2.newFixedThreadPool: 创建一个固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。
使用场景：FixedThreadPool 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
3.newScheduledThreadPool: 创建一个定时线程池，支持定时及周期性任务执行。
scheduleAtFixedRate，固定周期执行，周期到了没有分配到线程的任务就不执行了
scheduleWithFixedDelay，固定延迟，所有任务都会执行
execute(), 普通立马执行, 前面两种执行具体后面专门介绍一下，这里只是简单试验得出结论
使用场景:ScheduledThreadPoolExecutor 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, //调用ThreadPoolExecutor的构造方法
new DelayedWorkQueue());
}
4.newSingleThreadPool: 创建一个单线程化得线程池，它只会用唯一的工作线程执行任务，保证所有任务按照指定顺序（FIFO,LIFO,优先级）执行。
使用场景：SingleThreadExecutor 用于串行执行任务的场景，每个任务必须按顺序执行，不需要并发执行。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS, //keepAliveTime为0，表示空闲线程立即销毁，但此时corePoolSize=maxPoolSize,所以这个设置没有意义
new LinkedBlockingQueue<Runnable>())); //LinkedBlockingQueue队列最大容量Integer.MAX_VALUE,相当于没有上限
}
5.其他
5.1.阿里手册对线程池使用约定
【强制】线程池不允许使用Executors创建，而是通过ThreadPoolExecutor的方式创建，这样的处理方式能让编写代码的工程师更加明确线程池的运行规则，规避资源耗尽的风险。
附加说明：Executors返回线程池对象的弊端如下
1.FixedThreadPool和SingleThreadPool允许队列的长度Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2.CachedThreadPool和ScheduledThreadPool允许创建的线程数量为Integer.MAX_VALUE，可能会创建大量线程，从而导致OOM。
5.2 其他一些忘记总结的知识点
1.线程池状态，通过ThreadPoolExecutor的成员变量控制
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING,0));
ctl主要用于存储线程池的工作状态以及池中正在运行的线程数。显然要在一个整型变量存储两个数据，只能将其一分为二。其中高3bit用于存储线程池的状态，低位的29bit用于存储正在运行的线程数。
五种状态：
RUNNING,允许提交并处理任务；
SHUTDOWN,不允许提交新任务，但会处理已提交任务；
STOP,不允许提交新任务，也不会处理阻塞队列中未执行的任务，并设置正在执行线程的中断标志位；
TIDYING,所有任务执行完毕，池中工作线程数量为0，等待执行terminated()钩子方法；
TERMINATED, terminated()钩子方法执行完毕；
