目录
线程池的参数介绍
线程池的工作流程
使用Executors创建常见的线程池
池的思想，在计算机中是非常普遍的概念。顾名思义，池是将一个或多个任务提前创建好，放入容器中，当程序运行的时候直接取出使用，这个容器就叫线程池。随着时代的发展，并发编程的情况愈来愈多，对效率的要求也越来越高。频繁的创建销毁线程的开销，也变的越来越明显了。在这种情况下，可以引入线程池。
线程池的优点如下：
- 降低资源消耗：减少线程的创建和销毁带来的性能开销。
- 提高响应速度：当任务来时可以直接使用，不用等待线程创建
- 可管理性： 进行统一的分配，监控，避免大量的线程间因互相抢占系统资源导致的阻塞现象。
为啥引入线程池后，能够提升效率？
最关键的要点，是直接创建/销毁线程，是需要用户态+内核态配合完成的工作。而线程池的创建和销毁只需要通过用户态即可，不需要内核态的配合。
另一个原因，直接调用api，创建线程，销毁线程，这个过程需要内核完成。内核完成的工作很多的时候是不太可控的。如果使用线程池，提前把线程都创建好，放到用户态代码中写的数据结构里面，后面用的时候，随时从池子里取，用完了放回池子里去，这个过程，完全是用户态代码，不需要和内核进行交互。
线程池的参数介绍
我们下面使用java标准库中提供的ThreadPoolExector类来介绍关于线程池的一些参数。
1. 核心线程数（corePoolSize）与最大线程数（maximumPoolSize）
标准库的线程池把线程分为两类：1、核心线程(corePoolSize) 2、非核心线程
maximumPoolSize 就是核心线程数 + 非核心线程数
一个线程池，刚被创建出来的时候，里面就包含核心线程这么多的线程。线程池会提供一个submit方法，往里面添加任务，每个任务都是一个Runnable对象。
比如我们有4个核心线程数，如果当前添加的任务比较少，4个线程就足以能够处理，就只有4个线程在工作了。如果添加的任务比较多，4个线程处理不过来了（有很多的任务在排队等待执行）。这个时候，线程池就会自动创建出新的线程，来支撑更多的任务。创建出来的线程总数，不能超过最大线程数。过了一段时间后，任务没那么多了，线程清闲了，部分线程就会被释放掉（回收了），回收只是把非核心线程回收掉，至少会保证线程池中线程数目不少于核心线程数。
2、非核心线程允许空闲的最大时间（keepAliveTime）和时间单位（unit）
非核心线程是要在线程池不忙的时候回收掉，不是立即回收。例如，设定保留时间为3s，3s之内，非核心线程一直没有任务执行，就可以被回收了。unit表示时间的单位（分钟，小时，毫秒....），是个枚举类型。
3、任务队列（workQueue）
表示线程中的任务队列，线程池会提供submit方法，让其他线程把任务提交给线程池。线程池内部需要有一个队列这样的数据结构，把要执行的任务保存起来。后续线程池内部的工作线程，就会消费这个队列，从而来完成具体的任务执行。
4、线程工厂（threadFactory）
工厂模式的核心思路，是不再使用构造方法创建对象，而是给构造方法再包装一层。下面是一段工厂模式的代码。Point称为工厂类，通过类名PointBuilder调用方法，创建对象。主要解决了构造方法不能重载的问题。
class Point{
private double x;
public void setX(double x){
this.x = x;
}
}
class PointBuilder{
public static Point makePointByXY(double x,double y){
Point p =new Point();
p.setX(x);
p.setY(y);
return p;
}
public static Point makePointByRA(double r, double a){
Point p = new Point();
p.setR(r);
p.setA(a);
return p;
}
}
public class ThreadDemo21 {
public static void main(String[] args) {
Point p = PointBuilder.makePointByXY(10,20);
}
}
threadFactory是标准库中提供的，用来创建线程的工厂类。工厂类里面提供了工厂方法，工厂方法中封装了创建对象的过程。
我们除了可以使用Thread类来new一个线程对象，还可以使用工厂类提供的工厂方法来创建。线程工厂还可以批量的给要创建的线程设置一些属性。
5、拒绝策略（RejectedExecutionHandler handler）（重点）
拒绝策略是一个枚举类型。如果当前任务队列满了，仍然要继续添加任务，我们该怎么做？
如何处理这种情况就是拒绝策略：
1）直接抛出异常（程序运行结束）
2）令添加任务的submit调用者（submit内部要做的事情不仅仅是入队列，如果发现队列满 && 当前使用的这个拒绝策略，就会在submit内部自己去执行Rnnable的run方法），负责执行任务，线程池本身不管了。
3）丢弃最老的任务，让新的任务去队列中排队。
4）丢弃最新的任务，还是按照原有的节奏来执行。
线程池的工作流程
我们可以自己模拟实现一个简单的线程池，代码如下：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class MyThreadPool{
private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
private int maxPoolSize = 0;
private List<Thread> threadList = new ArrayList<>();
//初始化线程池（FixedThreadPool）
public MyThreadPool(int corePoolSize,int maxPoolSize){
this.maxPoolSize = maxPoolSize;
//创建若干个线程
for(int i = 0;i<corePoolSize;i++){
Thread t = new Thread(()->{
try {
while (true){
Runnable runnable = queue.take();
runnable.run();
}
}catch (InterruptedException e){
e.printStackTrace();
}
});
t.start();
threadList.add(t);
}
}
//把任务添加到线程池中
void submit(Runnable runnable) throws InterruptedException {
//此处进行判定当前任务队列的元素个数
//如果队列元素比较长，说明已有的线程，不太能够处理过来了，创建新的线程即可。
//如果队列不是很长，没必要创建新的线程。
queue.put(runnable);
//阈值都是随便想的
if(queue.size() >=500 && threadList.size() <maxPoolSize){
//创建新的线程
Thread t = new Thread(()->{
try {
while (true){
Runnable task = queue.take();
task.run();
}
}catch (InterruptedException e){
e.printStackTrace();
}
});
t.start();
}
}
}
public class ThreadDemo18 {
public static void main(String[] args) throws InterruptedException {
MyThreadPool threadPool = new MyThreadPool(10,20);
for (int i =0 ;i<10000;i++){
int id = i;
threadPool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello"+ id +" "+ Thread.currentThread().getName());
}
});
}
}
}
一个新的任务到线程池时，线程池的处理流程如下：
1.线程池判断核心线程池里的线程是否都在执行任务。 如果不是，创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。
2、线程池判断阻塞队列是否已满。 如果阻塞队列没有满，则将新提交的任务存储在阻塞队列中。如果阻塞队列已满，则进入下个流程。
3、线程池判断线程池里的线程是否都处于工作状态。 如果没有，则创建一个新的工作线程来执行任务。如果已满，则交给饱和策略来处理这个任务。
使用Executors创建常见的线程池
java标准库提供了创建线程池的工厂类Executors。可以帮助我们创建不同的线程池。
常用的分为以下4种：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class ThreadDemo19 {
public static void main(String[] args) {
//创建标准库线程池
//能够根据线程的数目，自动进行线程扩容
ExecutorService service = Executors.newCachedThreadPool();
//创建固定线程数目的线程池
ExecutorService service = Executors.newFixedThreadPool(4);
//创建一个只包含单个线程的线程池
ExecutorService service = Executors.newSingleThreadExecutor();
//创建一个固定线程个数，但是任务延时执行的线程池
ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
for(int i =0;i< 1000;i++){
int id =i;
service.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello" + id+","+Thread.currentThread().getName());
}
});
}
}
}
以上关于线程池，希望对你有所帮助。
