【通用开发】Java线程池
本文介绍了java线程池相关知识
线程的作用
public class Demo01 {
public static void main(String[] args) {
var thread = new Thread(() -> {
System.out.println("Hello world from a Java thread");
});
thread.start();
}
}
本质上Java编译器在编译的时候都认为传递给他的是一个对象，然后执行对象的run方法。
Thread在拿到这个对象的时候，当我们执行Thread的start方法的时候，最终会执行到一个native方法start0：
private native void start0();
当JVM执行到这个方法的时候会调用操作系统给上层提供的API创建一个线程，然后这个线程会去解释执行我们之前给Thread对象传入的对象的run方法字节码，当run方法字节码执行完成之后，这个线程就会退出。
看到这里我们仔细思考一下线程在做一件什么样的事情，JVM给我们创建一个线程好像执行完一个函数（run）的字节码之后就退出了，线程的生命周期就结束了。
确实是这样的，JVM给我们提供的线程就是去完成一个函数，然后退出（记住这一点，这一点很重要，为你后面理解线程池的原理有很大的帮助）。
事实上JVM在使用操作系统给他提供的线程的时候也是给这个线程传递一个函数地址，然后让这个线程执行完这个函数。只不过JVM给操作系统传递的函数，这个函数的功能就是去解释执行字节码，当解释执行字节码完成之后，这个函数也会退出（被系统回收）。
看到这里可以将线程的功能总结成一句话：
执行一个函数，当这个函数执行完成之后，线程就会退出，然后被回收，当然这个函数可以调用其他的函数。
可能你会觉得这句话非常简单，但是这句话会我们理解线程池的原理非常有帮助。
为什么需要线程池
当我们执行start的方法的时候，最终会走到start0方法，这是一个native方法，JVM在执行这个方法的时候会通过系统底层函数创建一个线程，然后去执行run方法，这里需要注意，创建线程是需要系统资源的，比如说内存，因为操作系统是系统资源的管理者，因此一般需要系统资源的方法都需要操作系统的参与，因此创建线程需要操作系统的帮忙，而一旦需要操作系统介入，执行代码的状态就需要从用户态到内核态转换（内核态能够执行许多用户态不能够执行的指令），当操作系统创建完线程之后又需要返回用户态，我们的代码将继续被执行，整个过程像下面这样。
从上图可以看到我们需要两次的上下文切换，同时还需要执行一些操作系统的函数，这个过程是非常耗时间的，如果在并发非常高的情况，我们频繁的去生成线程然后销毁，这对我们程序的性能影响还是非常大的。
因此许许多多聪明的程序员就想能不能不去频繁的创建线程而且也能够完成我们的功能——我们创建线程的目的就是想让我们的程序完成的更加快速，让多个不同的线程同时执行不同的任务，执行完这个任务再去阻塞队列取下一个任务执行。于是线程池就被创造出来了。
线程池的结构大致如下所示：
线程池实现原理
在前面我们已经提到了关于线程池和线程比较重要的两个点：
- 线程就是执行一个函数。
- 线程池当中的线程可以执行很多函数，但是不会退出。
那么如何实现上面两个要求？
答案就是在一个函数当中进行while循环，然后不断的从任务队列当中获取任务函数，然后进行执行，直到要求停止线程池当中的线程的时候线程再进行退出，整个过程的代码大致如下所示：
public void run() {
while (!isStopped) {
try {
Runnable task = tasks.take();
task.run();
} catch (InterruptedException e) {
// do nothing
}
}
}
为何要使用线程池？
- 降低开销：在创建和销毁线程的时候会产生很大的系统开销，频繁创建/销毁意味着CPU资源的频繁切换和占用，线程是属于稀缺资源，不可以频繁的创建。假设创建线程的时长记为
t1，线程执行任务的时长记为t2，销毁线程的时长记为t3，如果我们执行任务t2<t1+t3，那么这样的开销是不划算的，不使用线程池去避免创建和销毁的开销，将是极大的资源浪费。 - 易复用和管理：将线程都放在一个池子里，便于统一管理（可以延时执行，可以统一命名线程名称等），同时，也便于任务进行复用。
- 解耦：将线程的创建和销毁与执行任务完全分离出来，这样方便于我们进行维护，也让我们更专注于业务开发。
线程池的优势
- 提高资源的利用性：通过池化可以重复利用已创建的线程，空闲线程可以处理新提交的任务，从而降低了创建和销毁线程的资源开销。
- 提高线程的管理性：在一个线程池中管理执行任务的线程，对线程可以进行统一的创建、销毁以及监控等，对线程数做控制，防止线程的无限制创建，避免线程数量的急剧上升而导致CPU过度调度等问题，从而更合理的分配和使用内核资源。
- 提高程序的响应性：提交任务后，有空闲线程可以直接去执行任务，无需新建。
- 提高系统的可扩展性：利用线程池可以更好的扩展一些功能，比如定时线程池可以实现系统的定时任务。
线程池的类型
Java提供了一套Executor框架，封装了对多线程的控制，其体系结构如下图所示：
Executor只是一个接口，代码如下：
public interface Executor {
void execute(Runnable command);
}
ExecutorService接口对该接口进行了扩展，增加很多方法：
shutdown()
shutdowmNow()
isShutdown()
isTerminated()
awaitTermination()
submit(Callable<T>)
submit(Runnable,T)
submit(Runnable)
invokeAll()
重点关注前五个方法：
- shutdown(): 调用此方法通知线程池 shutdown，调用此方法后，线程池不再接受新的任务，已经提交的任务不会受到影响，会按照顺序执行完毕。不会阻塞调用此方法的线程。
- shutdowmNow()，立即尝试停止所有正在运行的任务，返回一个待执行的任务列表。不会阻塞调用此方法的线程。该方法除了尽力去尝试停止线程外，没有任何保证，任何响应中断失败的线程可能永远不会停止(如：通过thread.interrupted()中断线程时)。
- isShutdown()：返回一个boolean值，如果已经 shutdown 返回true，反之false。
- awaitTermination(timeout,timeUnit)：阻塞直到所有任务全部完成，或者等待 timeout ，或者在等待timeout期间当前线程抛出InterruptedException
- isTerminated(): 返回 true 如果所有的任务已经完成且关闭，否则返回false除非在先前已经调用过shutdown()/shutdownNow()
AbstractExecutorService 是一个抽象类，实现了 ExecutorService ，其子 ThreadPoolExecutor 进一步扩展了相关功能。Java中提供了一个工具类供我们去使用 ThreadPoolExecutor ，在 Executors 中提供了如下几种线程池。
这么多的线程池，但都是给ThreadPoolExecutor的构造函数传递不同的参数罢了。
线程池的创建与使用
ThreadPoolExecutor的构造函数：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
七大构造参数
int corePoolSize：该线程池中核心线程数最大值
这边我们区分两个概念：
- 核心线程：线程池新建线程的时候，当前活动的线程总数< corePoolSize，新建的线程即为核心线程。
- 非核心线程：线程池新建线程的时候，当前活动的线程总数> corePoolSize， 且阻塞队列已满，这时新建一个线程来执行新提交的任务即为非核心线程。
核心线程默认情况下会一直存活在线程池中，即使这个核心线程不工作(空闲状态)，除非ThreadPoolExecutor 的 allowCoreThreadTimeOut这个属性为 true，那么核心线程如果空闲状态下，超过一定时间后就被销毁。
int maximumPoolSize：线程总数最大值
线程总数 = 核心线程数 + 非核心线程数
long keepAliveTime：非核心线程空闲超时时间
keepAliveTime即为空闲线程允许的最大的存活时间。如果一个非核心线程空闲状态的时长超过keepAliveTime了，就会被销毁掉。注意：如果设置allowCoreThreadTimeOut = true，就变成核心线程超时销毁了。
TimeUnit unit：是keepAliveTime 的单位
TimeUnit为枚举类型，列举如下：
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
BlockingQueue workQueue：存放任务的阻塞队列
当核心线程都在工作的时候，新提交的任务就会被添加到这个工作阻塞队列中进行排队等待；如果阻塞队列也满了，线程池就新建非核心线程去执行任务。
workQueue维护的是等待执行的Runnable对象。常用的 workQueue 类型：（无界队列、有界队列、同步移交队列）
- SynchronousQueue：同步移交队列，适用于非常大的或者无界的线程池，可以避免任务排队，SynchronousQueue队列接收到任务后，会直接将任务从生产者移交给工作者线程，这种移交机制高效。它是一种不存储元素的队列，任务不会先放到队列中去等线程来取，而是直接移交给执行的线程。只有当线程池是无界的或可以拒绝任务的时候，SynchronousQueue队列的使用才有意义，maximumPoolSize 一般指定成 Integer.MAX_VALUE，即无限大。要将一个元素放入SynchronousQueue，就需要有另一个线程在等待接收这个元素。若没有线程在等待，并且线程池的当前线程数小于最大值，则ThreadPoolExecutor就会新建一个线程；否则，根据饱和策略，拒绝任务。newCachedThreadPool默认使用的就是这种同步移交队列。吞吐量高于LinkedBlockingQueue。
- LinkedBlockingQueue：基于链表结构的阻塞队列，FIFO原则排序。当任务提交过来，若当前线程数小于corePoolSize核心线程数，则线程池新建核心线程去执行任务；若当前线程数等于corePoolSize核心线程数，则进入工作队列进行等待。LinkedBlockingQueue队列没有最大值限制，只要任务数超过核心线程数，都会被添加到队列中，这就会导致运行中的总线程数永远不会超过 corePoolSize，所以maximumPoolSize 是一个无效设定。newFixedThreadPool和newSingleThreadPool默认是使用的是无界LinkedBlockingQueue队列。吞吐量高于ArrayBlockingQueue。
- ArrayBlockingQueue：基于数组结构的有界阻塞队列，可以设置队列上限值，FIFO原则排序。当任务提交时，若当前线程小于corePoolSize核心线程数，则新建核心线程执行任务；若当先线程数等于corePoolSize核心线程数，则进入队列排队等候；若队列的任务数也排满了，则新建非核心线程执行任务；若队列满了且总线程数达到了maximumPoolSize最大线程数，则根据饱和策略进行任务的拒绝。
- DelayQueue：延迟队列，队列内的元素必须实现 Delayed 接口。当任务提交时，入队列后只有达到指定的延时时间，才会执行任务。
- PriorityBlockingQueue：优先级阻塞队列，根据优先级执行任务，优先级是通过自然排序或者是Comparator定义实现。
ThreadFactory threadFactory
创建线程的方式，这是一个接口，你 new 他的时候需要实现他的 Thread newThread(Runnable r) 方法，一般用不上。
RejectedExecutionHandler handler：饱和策略
抛出异常专用，当队列和最大线程池都满了之后的拒绝策略。 JDK提供了几种不同的RejectedExecutionHandler实现：
- CallerRunsPolicy : 调用线程处理任务
- AbortPolicy : 抛出异常
- DiscardPolicy : 直接丢弃
- DiscardOldestPolicy : 丢弃队列中最老的任务，执行新任务
//默认策略，阻塞队列满，则丢任务、抛出异常
rejected = new ThreadPoolExecutor.AbortPolicy();
//阻塞队列满，则丢任务，不抛异常
rejected = new ThreadPoolExecutor.DiscardPolicy();
//删除队列中最旧的任务（最早进入队列的任务），尝试重新提交新的任务
rejected = new ThreadPoolExecutor.DiscardOldestPolicy();
//队列满，不丢任务，不抛异常，若添加到线程池失败，那么主线程会自己去执行该任务
rejected = new ThreadPoolExecutor.CallerRunsPolicy();
另外还有一个CallerRunsPolicy
CallerRunsPolicy
其为“调用者运行”策略，实现了一种调节机制 。它不会抛弃任务，也不会抛出异常。 而是将任务回退到调用者。它不会在线程池中执行任务，而是在一个调用了execute的线程中执行该任务。在线程满后，新任务将交由调用线程池execute方法的主线程执行，而由于主线程在忙碌，所以不会执行accept方法，从而实现了一种平缓的性能降低。
当工作队列被填满后，没有预定义的饱和策略来阻塞execute（除了抛弃就是中止还有去让调用者去执行）。然而可以通过Semaphore来限制任务的到达率。
线程池的状态
- RUNNING：运行状态，指可以接受任务并执行队列里的任务。
- SHUTDOWN：调用了 shutdown() 方法，不再接受新任务，但队列里的任务会执行完毕。
- STOP：指调用了 shutdownNow() 方法，不再接受新任务，所有任务都变成STOP状态，不管是否正在执行。该操作会抛弃阻塞队列里的所有任务并中断所有正在执行任务。
- TIDYING：所有任务都执行完毕，程序调用 shutdown()/shutdownNow() 方法都会将线程更新为此状态，若调用shutdown()，则等执行任务全部结束，队列即为空，变成TIDYING状态；调用shutdownNow()方法后，队列任务清空且正在执行的任务中断后，更新为TIDYING状态。
- TERMINATED：终止状态，当线程执行 terminated() 后会更新为这个状态。 关闭线程池 两种关闭线程池的区别:
- shutdown()： 执行后停止接受新任务，会把队列的任务执行完毕。
- shutdownNow()： 执行后停止接受新任务，但会中断所有的任务（不管是否正在执行中），将线程池状态变为 STOP状态。
