目录
- java线程池概述
- `Executor`接口
- `ExecutorService`接口
- 工具类快速创建线程池
- FixedThreadPool
- SingleThreadExecutor
- CachedThreadPool
- ScheduledThreadPool
- 内置线程池总结
java线程池概述
Executor框架是Java提供的一个用于处理并发任务的工具。它简化了线程管理，提供了一个更高层次的任务执行模型。Executor框架的核心组成部分包括Executor接口、ExecutorService接口以及ScheduledExecutorService接口。下面是这些组件的详细介绍：
Executor接口
Executor是Java并发框架中的基础接口，用于提交任务。它有一个方法：
java复制代码
void execute(Runnable command);
这个方法接收一个Runnable对象，并在某个线程中执行它。Executor接口并不提供任务完成后的反馈机制，它只是将任务提交到线程池中执行。
ExecutorService接口
ExecutorService接口继承了Executor接口，提供了一些额外的方法来管理和控制线程池的生命周期。主要的方法包括：
submit(Runnable task): 提交一个Runnable任务，并返回一个Future对象，允许你在将来获取任务的执行结果或异常。submit(Callable<T> task): 提交一个Callable任务，并返回一个Future<T>对象，允许你获取任务的结果。invokeAll(Collection<? extends Callable<T>> tasks): 提交一组Callable任务，并返回一个List<Future<T>>对象，表示任务的执行结果。invokeAny(Collection<? extends Callable<T>> tasks): 提交一组Callable任务，并返回第一个成功完成的任务的结果。shutdown(): 启动一次平滑关机，停止接收新任务，但会继续执行已经提交的任务。shutdownNow(): 立即关闭，尝试停止所有正在执行的任务，返回未执行的任务列表。
Executor框架关系图：
线程池常用方法：
//使用工具类创建线程池
ExecutorService executor1 = Executors.newFixedThreadPool(3);//定义任务
Runnable task = ()->{System.out.println("线程"+Thread.currentThread().getName()+"正在执行");
};executor.excute(XXX); //执行任务，没有返回值
executor.submit(XXX);//执行任务，返回一个Future，用于获取线程的执行情况executor.shutdown();//正常关闭，停止提交新任务，而已提交的任务可以正常执行，非阻塞
executor.shutdownNow();//立即强制关闭，停止提交新任务，正在运行的任务停止，等待队列也销毁，非阻塞
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); // 阻塞等待所有任务完成并且shutdown，如果超过到达时间，则返回false
当等待队列是无界队列时，非核心线程会创建吗？
不会，因为非核心线程只有在队列满的时候才会创建，使用了无界队列就相当于默认只有核心线程生效
工具类快速创建线程池
Executors是一个工具类，可以快速创建线程池，它支持四种创建方式
public static void main(String[] args) {long start = System.currentTimeMillis();ExecutorService executor1 = Executors.newFixedThreadPool(3);//固定线程池，线程不变ExecutorService executor2 = Executors.newCachedThreadPool();//缓冲线程池，自由伸缩ExecutorService executor3 = Executors.newSingleThreadExecutor();//单线程池，FIFOScheduledExecutorService executor4 = Executors.newScheduledThreadPool (5);// 调度线程池，用于实现定时任务、周期任务}
FixedThreadPool
使用示例：
private static void runFixedThreadPoolExample() {long startTime = System.currentTimeMillis(); // 记录开始时间// 创建一个固定大小的线程池，线程池大小为3ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);// 提交10个任务到线程池for (int i = 0; i < 10; i++) {final int taskId = i;fixedThreadPool.execute(() -> {System.out.println("FixedThreadPool: 任务 " + taskId + " 在 " + Thread.currentThread().getName() + " 执行");try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {e.printStackTrace();}});}fixedThreadPool.shutdown(); // 关闭线程池，停止接受新任务try {fixedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); // 等待所有任务完成} catch (InterruptedException e) {e.printStackTrace();}long endTime = System.currentTimeMillis(); // 记录结束时间System.out.println("FixedThreadPool 运行时长: " + (endTime - startTime) + " 毫秒"); // 打印运行时长}
底层参数：
public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}
特点：
- 核心线程数和最大线程数大小一样，没有所谓的非核心线程的空闲时间
- 阻塞队列为无界队列LinkedBlockingQueue，可能会导致OOM
使用场景：适用于任务数量相对固定且执行周期长的任务。因为创建的都是核心线程，会一直存在，所以如果是短周期任务的话，比较浪费资源。任务并发量不确定的情况也最好不用。
SingleThreadExecutor
使用示例：
private static void runSingleThreadExecutorExample() {long startTime = System.currentTimeMillis(); // 记录开始时间// 创建一个单线程的线程池ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();// 提交5个任务到线程池for (int i = 0; i < 5; i++) {final int taskId = i;singleThreadExecutor.execute(() -> {System.out.println("SingleThreadExecutor: 任务 " + taskId + " 在 " + Thread.currentThread().getName() + " 执行");try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {e.printStackTrace();}});}singleThreadExecutor.shutdown(); // 关闭线程池，停止接受新任务try {singleThreadExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); // 等待所有任务完成} catch (InterruptedException e) {e.printStackTrace();}long endTime = System.currentTimeMillis(); // 记录结束时间System.out.println("SingleThreadExecutor 运行时长: " + (endTime - startTime) + " 毫秒"); // 打印运行时长}
底层参数：
public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}
特点：
- 核心线程数和最大线程数都是1，即只用一个线程去执行所有任务
- 阻塞队列是无界队列LinkedBlockingQueue，可能会导致OOM
使用场景：当要实现串行执行任务，满足排队执行时
CachedThreadPool
使用示例：
private static void runCachedThreadPoolExample() {long startTime = System.currentTimeMillis(); // 记录开始时间// 创建一个可缓存的线程池ExecutorService cachedThreadPool = Executors.newCachedThreadPool();// 提交10个任务到线程池for (int i = 0; i < 10; i++) {final int taskId = i;cachedThreadPool.execute(() -> {System.out.println("CachedThreadPool: 任务 " + taskId + " 在 " + Thread.currentThread().getName() + " 执行");try {Thread.sleep(1000); // 模拟任务执行} catch (InterruptedException e) {e.printStackTrace();}});}cachedThreadPool.shutdown(); // 关闭线程池，停止接受新任务try {cachedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); // 等待所有任务完成} catch (InterruptedException e) {e.printStackTrace();}long endTime = System.currentTimeMillis(); // 记录结束时间System.out.println("CachedThreadPool 运行时长: " + (endTime - startTime) + " 毫秒"); // 打印运行时长}
底层参数：
public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}
特点：
- 核心线程数为0，所有线程都是非核心线程，空闲后最多存活60秒
- 最大线程数为Integer.MAX_VALUE，即无限大，可能会因为无限创建线程，导致OOM
- 阻塞队列是SynchronousQueue，这个队列的size为1，也就是每提交一个任务，队列都会满，进而就都会创建一个非核心线程
使用场景： 执行并发量大且事件短的小任务，需要快速响应的场景
ScheduledThreadPool
使用示例：
private static void runScheduledThreadPoolExample() {long startTime = System.currentTimeMillis(); // 记录开始时间// 创建一个调度线程池，线程池大小为2ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);// 延迟任务，2秒后执行scheduledThreadPool.schedule(() -> {System.out.println("延迟任务执行: 线程 " + Thread.currentThread().getName() + " 执行了延迟任务");}, 2, TimeUnit.SECONDS);// 周期任务，立即开始执行，每5秒执行一次scheduledThreadPool.scheduleAtFixedRate(() -> {System.out.println("周期任务执行: 线程 " + Thread.currentThread().getName() + " 执行了周期任务");}, 0, 5, TimeUnit.SECONDS);// 让主线程运行一段时间，以便观察周期任务的执行try {Thread.sleep(20000); // 主线程睡眠20秒} catch (InterruptedException e) {e.printStackTrace();}long endTime = System.currentTimeMillis(); // 记录结束时间System.out.println("ScheduledThreadPool 运行时长: " + (endTime - startTime) + " 毫秒"); // 打印运行时长}
底层参数：
public ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue());}
特点：
- 核心线程数可自定义，而最大线程数是Integer.MAX_VALUE，所以也有OOM的风险
- 阻塞队列是DelayedWorkQueue，按照预期开始时间进行排序
- scheduleAtFixedRate() ：按某种速率周期执行
- scheduleWithFixedDelay()：在某个延迟后执行
使用场景：当要执行延时任务或者周期性任务时
内置线程池总结
总结四种线内置程池都相对比较极端，具体如下：
- FixedThreadPool：固定线程池，只有核心线程，线程完全固定
- CachedThreadPool：缓冲线程池，只有非核心线程，线程完全弹性
- SingleThreadExecutor：单线程池，只能实现排队等待，完全没有并发
- ScheduledThreadPool：调度线程池，实现延时任务和周期任务，非核心线程数没有上限
注意：《阿里巴巴java开发手册》中明确禁止使用工具类的创建方式，因为线程池的参数不明确，所以不推荐使用工具类创建线程池
![[Python]一、Python基础编程](https://i-blog.csdnimg.cn/direct/f602a12f2f6a44c6b5953c23294b7084.png)
