一、什么是线程池？
线程池是一种管理线程的机制，用于复用线程资源，减少线程创建和销毁的开销，从而提高程序性能；线程池中的线程在完成任务后不会立即销毁，而是被放回线程池，等待执行新的任务
二、线程池参数介绍
ThreadPoolExecutor构造方法：
public ThreadPoolExecutor(int corePoolSize, //核心线程数量
int maximumPoolSize,// 最大线程数
long keepAliveTime, // 最大空闲时间
TimeUnit unit, // 时间单位
BlockingQueue<Runnable> workQueue, // 任务队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 饱和处理机制
)1.核心线程数（corePoolSize）:线程池中始终保持的线程数.当线程池中的线程数小于核心线程数时,即使有空闲线程,新任务也会创建新的线程执行.
2.最大线程数（maximumPoolSize）:线程池中允许的最大线程数.
3.工作队列（workQueue）:用于存储等待执行的任务的阻塞队列。当核心线程数满时，新任务会进入工作队列等待执行。
4.线程空闲时间（keepAliveTime）：当线程池中的线程数大于核心线程数时，多余的空闲线程在等待新任务的最长时间。超过这个时间，空闲线程将被销毁。
5.线程工厂（ThreadFactory）:用于创建新线程的工厂对象。
6.拒绝策略（RejectedExecutionHandler）:当线程池无法处理新任务时采取的拒绝策略.
拒绝策略
1.AbortPolicy（默认）:直接抛出RejectedExecutionException异常,不执行被拒绝的任务
2.CallerRunsPolicy:将被拒绝的任务交给调用线程池的线程（通常是主线程）来执行。这种策略可以降低新任务提交的速度，从而为线程池腾出时间来处理更多任务.
3.DiscardPolicy:当新任务被提交后直接被丢弃掉,不执行也不抛出异常.
4.DiscardOldestPolicy:丢弃工作队列中最旧的任务,然后将新任务添加到工作队列中.如果队列中的任务是有序的或存在依赖关系,这种策略可能导致问题.
三、线程池工作流程
当有新任务提交时,线程池会根据核心线程数创建新线程来执行任务.
如果当前线程数达到核心线程数,新任务会被放入工作队列中.
如果工作队列已满,线程池会创建新线程来执行任务,直到线程数达到最大线程数.
如果线程数已达到最大线程数且工作队列已满,线程池会根据拒绝策略处理新任务.
当线程池中的线程数大于核心线程数且空闲时间超过keepAliveTime时,多余的空闲线程将被销毁.
四、使用Executors创建常见线程池
Java通过Executors工厂类提供四种线程池，分别为：
- newCachedThreadPool ：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，否则新建线程。（线程最大并发数不可控制）
- newFixedThreadPool：创建一个固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。
- newScheduledThreadPool ： 创建一个定时线程池，支持定时及周期性任务执行。
- newSingleThreadExecutor ：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newCachedThreadPool
public class CachedThreadPoolTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
executorService.execute(myRunnable);
}
System.out.println("线程任务开始执行");
executorService.shutdown();
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running...");
}
}源码：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}通过上面的源码我们可以看到，newCachedThreadPool没有核心线程个数，就像一个餐厅，招聘的全是临时工，而且它的非核心线程无上限，每个临时线程空闲时间只存活60秒
执行流程：
1.没有核心线程，直接向 SynchronousQueue 中提交任务
2.如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个
3.执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续存在，否则就被回收掉了
因为空闲 60 秒的线程就会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。
newFixedThreadPool
public class FixedThreadPoolTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
executorService.execute(myRunnable);
}
System.out.println("线程任务开始执行");
executorService.shutdown();
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running...");
}
}源码：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}我们通过源码可以看到，FixedThreadPool 的核心线程数和最大线程数都是我们可以指定的， keepAliveTime 为 0，也就是多余的空余线程会被立即终止
执行流程：
- 线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务
- 线程数等于核心线程数后，将任务加入阻塞队列
- 由于队列容量非常大，可以一直加
- 执行完任务的线程反复去队列中取任务执行
FixedThreadPool 主要用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。
newScheduledThreadPool
public class ScheduledThreadPoolTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
// 参数1:目标对象,参数2:隔多长时间开始执行线程,参数3:执行周期,参数4:时间单位
scheduledExecutorService.scheduleAtFixedRate(myRunnable, 1, 2, TimeUnit.SECONDS);
}
System.out.println("线程任务开始执行");
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running...");
}
}newSingleThreadExecutor
public class SingleThreadExecutorTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
MyRunnable myRunnable = new MyRunnable();
for (int i = 0; i < 5; i++) {
executorService.execute(myRunnable);
}
System.out.println("线程任务开始执行");
executorService.shutdown();
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running...");
}
}
