1.线程池是什么
1.1 线程池
本来多进程就是解决并发编程的方案，但是进程有点太重量了（创建和销毁开销比较大），因此引入了线程，线程比进程要轻量很多。即便如此，如果在某些场景中需要频繁的创建和销毁线程，线程的创建销毁开销也就无法忽视了。
为了解决这样的问题，我们引入了线程池：
使用线程的时候，不是说用的时候才创建，而是提前创建好，放到一个“池子”里（类似于字符串常量池），当我们需要使用线程的时候，直接从池子里面取一个线程出来，当我们不需要这个线程的时候，就把这个线程还回池子中（此时我们的操作就会比创建销毁线程效率更高）。
为了更好的理解线程池的概念我们引入下边这个例子：
在我们找工作时，面试结束之后会面临两个结果，1是已经通过oc(offer call)，2是没有通过，但是公司不会直接告诉你你没有通过，而是完全不通知（公司会把你放到“人才储备池”里），此时假设A公司要招100人而目前只招够了60个人，剩下的40个名额公司将会从“人才储备池”中直接挑选hc(head count),直接发offer，从而避免了需要再次笔试面试等一系列的流程来招纳新人。
如果是真的创建/销毁线程，就会涉及到用户态和内核态的切换。
如果不是真的创建销毁线程，而是放到池子里，就相当于全在用户态搞定了这个事情。
在用户态操作会比较高效，切换到内核态以后操作就可能很低效。
线程池最大的好处就是减少每次启动、销毁线程的损耗
下边便是用户态和内核态的具体介绍
1.2 用户态与内核态
用户态就是应用程序执行的代码，内核态就是操作系统内核执行的代码，一般认为，用户态和内核态之间的切换，是一个开销比较大的操作。
比如我们去银行办理业务时，需要去复印一份文件，如果我们自己去复印，就能够很快的完成并交给工作人员，但如果让工作人员去完成这个打印文件的工作就会比较耗费时间（工作人员需要完成的工作很多，不能及时调度去完成打印文件工作）。
此时的我们便是用户态，工作人员便是内核态。
2.标准库中的线程池
在Java的标准库中，有下边这两者方式来创建线程池
2.1 ThreadPoolExecutor
ThreadPoolExecutor的使用是相对复杂的，因为里边有很多的参数，ThreadPoolExecutor的构造方法的参数是什么意思，便是一道经典的面试题：（）中的含义在下边引用中有介绍
- corePoolSize ：核心线程数（正式员工的数量）
- maximumPoolSize：最大线程数（正式工+临时工）
- keepAliveTime：线程保持活动的时间（描述临时工摸鱼可以摸多久）
- unit：keepAliveTime的时间单位（ms,s,minute）
- workQueue：阻塞队列，组织了线程池要执行的任务
- threadFactory：线程的创建方式，通过这个参数，来设定不同的线程的创建方式
- RejectedExecutionHandler：拒绝策略，当任务队列满了的时候，又来了新的任务，要根据具体的业务场景来选取具体的拒绝策略
我们可以把线程池想象成一个“公司”，公司里面的每个员工，就相当于是一个线程。
员工分为两类：
1，正式工（corePoolSize）：签了劳动合同的，不能随便辞退
2，临时工：没有签劳动合同，随时可以踢掉
正式员工允许摸鱼（这样的线程即使是空闲，也不会被销毁）
临时工不允许摸鱼（如果临时工线程摸鱼的时间到了一定程度，就会被销毁）
如果我们要解决的任务场景任务量比较稳定，就可以设置corePoolSize和maximumPoolSize尽量接近（临时工就可以少一些）
如果我们要解决的任务场景任务量波动较大，既可以设置corePoolSize和maximumPoolSize相差大一些（临时工就可以多一些）
我们需要主要了解的是拒绝策略，在实际开发中，要根据具体的业务场景来选取具体的拒绝策略：
以老板给员工分配工作的任务为例，来引出这四种拒绝策略：（员工相当于线程池）
1.老板给员工分配了很多任务，员工即使加班也无法完成工作，导致情绪崩溃，所有的工作都不干了。
2.老板给员工分配了很多任务，员工完不成的老板接手，如果老板也无法完成，就丢弃任务。
3.老板给员工安排了工作1、2、3、4，此时员工搞不定了，就可以先丢弃工作1（最旧的），去干其他的工作。
4.老板给员工安排了工作1、2、3、4，此时员工搞不定了，就可以先丢弃工作4（最新的），去干其他的工作。
1.AbortPolicy:中止策略，线程池会抛出异常并中止执行此任务；
2.CallerRunsPolicy:把任务交给添加此任务的线程来执行；
3.DiscardOldestPolicy:忽略最先加入队列的任务(最老的任务)；
4.DiscardPolicy:忽略此任务(最新加入的任务)。
面试题：
线程池的数目如何确定？或者说设置成几比较合适？
我们并不能给出确定的具体个数，原因有以下两点：
1.主机的CPU配置不确定
2.程序的执行特点不确定
所以只有针对程序进行性能测试，分别给线程池设置成不同的数目，分别记录每种情况，才能最终选一个合适的配置。
2.2 Executors
由于ThreadPoolExecutor使用起来比较复杂，标准库又提供了Executors类，相当于对ThreadPoolExecutor又进行了一层封装，这个类相当于一个“工厂类”，通过这个类提供的一组工厂方法，就可以创建出不同风格的线程池实例了。（工厂模式在2.3中讲解）
Executors 创建线程池的几种方式：
- newFixedThreadPool: 创建固定线程数的线程池（完全没有临时工的版本）
- newCachedThreadPool: 创建线程数目可变的线程池.（完全没有正式员工，全是临时工）
- newSingleThreadExecutor: 创建只包含单个线程的线程池. （只在特定场景下使用）
- newScheduledThreadPool: 能够设定延时时间的线程池（插入的任务能够过一会再执行），相当于进阶版的定时器。
代码示例：
public class Demo2 { public static void main(String[] args) { //用标准库中的线程池，创建出一个线程池中的实例 ExecutorService pool= Executors.newCachedThreadPool(); //给这个实例里面加入一些任务 for (int i = 0; i < 5; i++) { pool.submit(new Runnable() { @Override public void run() { System.out.println("hello"); } }); } } }
2.3 工厂模式
Executors类的几种创建线程池的方式就是工厂模式的体现，工厂模式也是一种设计模式，和单例模式是并列的关系，工厂模式存在的意义，就是弥补构造方法的一些缺陷。
工厂模式主要是为了创建实例，正儿八经的创建实例是通过构造方法，但是构造方法的限制比较多：
1.构造方法的名字，必须是固定的（类名）
2.如果需要多个版本的构造方式，就只能依赖构造方法的重载，但是重载方法又要求方法参数的个数和类型不一致。
比如下边这个例子：
假设我们有个类Point，我们希望通过笛卡尔坐标和极坐标两种方式来构造这个点
class Point { public Point(double x,double y){...} -->笛卡尔坐标 public Point(double r,double a){...} -->极坐标 }
但是这俩方法的参数个数和类型都一样，这个时候编译不了，而且构造方法的方法名是固定的，光看方法名并不知道咱们是使用哪种方式构造
为了解决这个问题：
我们就不使用构造方法来构造实例了，而是使用其他的方法来进行构造实例，这样的用来构造实例的方法就被称为“工厂方法”。
工厂方法其实就是普通的方法，这个工厂方法里面会调用对应的构造方法，并进行一些初始化的操作，并返回这个对象的实例。
实现线程池
- 核心操作为 submit, 将任务加入线程池阻塞队列中，并创建线程
- 使用一个 BlockingQueue 组织所有的任务
- 一个线程池可以同时提交N个任务，对应的线程池中有M个线程来负责完成这N个任务，利用生产者消费者模型，把N个任务分配给M个线程
import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; class MyThreadPool { private BlockingQueue<Runnable> queue=new LinkedBlockingQueue<>(); public void submit(Runnable runnable) throws InterruptedException { queue.put(runnable); } public MyThreadPool(int m) { //在构造方法中，创建出M个线程，负责完成工作 for (int i = 0; i < m; i++) { Thread t=new Thread(()-> { while (true) { try { Runnable runnable=queue.take(); runnable.run(); } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); } } }
检测实现的线程池：
public class Demo { public static void main(String[] args) throws InterruptedException { MyThreadPool pool=new MyThreadPool(10); for (int i = 0; i < 1000; i++) { int taskId=i;//注意匿名内部类的变量捕获 pool.submit(new Runnable() { @Override public void run() { System.out.println("执行当前任务:"+taskId+"当前线程:"+Thread.currentThread().getName()); } }); } } }
线程池的执行流程：
- 1.当新加入一个任务时，先判断当前线程数是否大于核心线程数，如果结果为false，则新建线程并执行任务；
- 2.如果结果为true，则判断任务队列是否已满，如果结果为false,则把任务添加到任务队列中，等待线程执行
- 3.如果结果为true，则判断当前线程数量是否超过最大线程数；如果结果为false，则新建线程执行此任务
- 4.如果结果为true，执行拒绝策略。
