Java多线程——线程池，全方面解答，小白收藏这篇也足够了-编程阁

线程池

1.1 什么是线程池

线程池是一种多线程管理机制，通过池化技术来重用现有线程而不是创建新的线程，从而降低线程创建和销毁的开销。线程池通过工作队列和线程管理来实现高效的任务执行。

1.2 为什么使用线程池

一个线程大约占用的内存为1M
解决频繁创建线程和销毁线程消耗的性能
解决大量创建线程而导致的内存泄露问题

线程池的优点

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的销毁
提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行
提高线程的可管理性
线程可以复用、可以控制最大并发数、可以管理线程

1.3 线程池的组成

线程池的关键组成部分包括：

线程池管理器(ThreadPoolExecutor):负责创建、管理和控制线程池。
工作队列：用于存储待执行的任务。
线程池线程：实际执行任务的线程。线程池中会维护一组线程，这些线程可以被重复使用，从而避免了频繁创建和销毁的开销

1.4 如何创建线程池

Java提供了两种方式：

第一种：通过工具类完成线程池的创建【Executors】，语法简单，但是阿里巴巴不建议使用
第二种：通过线程池类【ThreadPoolExecutor】，语法复杂，但是阿里巴巴建议使用，灵活

线程的根接口：Executor，其中只有一个方法：execute。
线程的子接口：ExecutorService，其中方法有很多。

1.4.1 第一种方式–Executors工具类

① 固定大小线程池对象 newFixedThreadPool

语法格式
//创建一个固定大小的线程池，返回类型为ExecutorService ExecutorService executorService = Executors.newFixedThreadPool(5);
介绍
该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变，当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

public class Test1 { public static void main(String[] args) { //创建一个固定大小的线程池，返回类型为ExecutorService ExecutorService executorService = Executors.newFixedThreadPool(5); for (int i = 0; i < 20; i++) { //调用execute方法，参数必须传递Runnable对象。 //传递Runnable对象的三种方式 //[1]自己创建一个类实现Runnable接口 [2]匿名内部类对象 [3]lambda表达式: 前提接口必须为函数式接口。 executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"--->"+i)); } } }

② 单一线程池 newSingleThreadExecutor

语法
//创建单一线程池，返回类型ExecutorService ExecutorService executorService = Executors.newSingleThreadExecutor();
介绍
该方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

public class Test2 { public static void main(String[] args) { //创建单一线程池，返回类型ExecutorService ExecutorService executorService = Executors.newSingleThreadExecutor(); for (int i = 0; i < 50; i++) { executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"===========")); } } }

③ 可变线程池 newCachedThreadPool

语法
//创建可变大小的线程池，返回类型ExecutorService ExecutorService executorService = Executors.newCachedThreadPool();
介绍
该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

public class Test3 { public static void main(String[] args) { //创建可变大小的线程池，返回类型ExecutorService ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i < 20; i++) { executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~")); } } }

④ 延迟线程池 newScheduledThreadPool

语法
//创建延迟线程池，返回类型为ScheduledExecutorService ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
介绍
该方法返回的是一个支持定时及周期性的线程池。该线程池对象执行的不是excute方法，执行的是schedule方法。
schedule方法中的三个参数为：
传递Runnable对象或Callable对象
设置多长时间后开始执行任务代码块
设置时间单位

public class Test4 { public static void main(String[] args) { //创建延迟线程池，返回类型为ScheduledExecutorService ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3); for (int i = 0; i < 20; i++) { //schedule方法，必须传递Callable对象 scheduledExecutorService.schedule( ()->{ System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~"); }， 5, //表示5秒后执行任务代码块 TimeUnit.SECONDS ); } } }

亦或者执行scheduleAtFixedRate方法
其中包含四个参数为：
传递Runnable对象或Callable对象
设置多长时间后开始执行任务代码块
设置每隔多长时间执行一次代码块
设置时间单位

public class Test5 { public static void main(String[] args) { ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2); for (int i = 0; i < 5; i++) { //scheduleAtFixedRate:必须传递Runnable接口 scheduledExecutorService.scheduleAtFixedRate( ()-> { System.out.println(Thread.currentThread().getName()+"~~~~~~~~~"); },//对象 3, //3秒后执行任务 2, //2秒执行一次 TimeUnit.SECONDS //时间单位为秒 ); } } }

1.4.2 Executors创建的线程池缺点

《阿里巴巴java开发手册》中强制线程池不允许使用Exexutors去创建，而是通过ThreadPoolExextor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下： FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE, 可能堆积大量的请求，从而导致OOM。（Out Of Memory：内存用完了！） CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE， 可能会创建大量线程，从而导致OOM。

1.4.3 线程池的七大参数

int corePoolSize：核心线程数量，不能小于0
int maximumPoolSize ：最大线程的线程数量，减去核心线程=临时线程
long keepAliveTime ：空闲线程的最大存活时间，没有人使用会自动释放
TimeUnit unit ：时间单位
BlockingQueue workQueue ：任务队列
ThreadFactory th：线程工厂，创建线程的，一般不用动
RejectedExecutionHandler handler ：任务的拒绝策略

1.4.4 第二种方式–ThreadPoolExecutor

① 语法介绍

语法
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(参数列表);
参数介绍
int corePoolSize：核心线程数的个数
int maximumPoolSize：最大线程数量
long keepAliveTime：非核心线程允许空闲的时间
TimeUnit unit：时间单位
BlockingQueue workQueue：堵塞队列

public class Test1 { public static void main(String[] args) { //创建任务队列 BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(3); //创建线程池 ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2,6,6, TimeUnit.SECONDS,workQueue); for (int i = 0; i < 9; i++) { //调用submit方法，执行线程任务 threadPoolExecutor.submit(()->{ System.out.println(Thread.currentThread().getName()+"~~~~~~~~~"); }); } } }

② 场景理解

我们可以通过下面的场景理解ThreadPoolExecutor中的各个参数; a客户(任务)去银行(线程池)办理业务,但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0), 于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程); 在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员(创建2号线程执行任务)接待b客户(又创建了一个新的线程);假设该银行总共就2个窗口(核心线程数量是2); 紧接着在a,b客户都没有结束的情况下c客户来了,于是经理(线程池管理者)就安排c客户先坐到银行大厅的座位上(空位相当于是任务队列)等候, 并告知他: 如果1、2号工作人员空出,c就可以前去办理业务; 此时d客户又到了银行,(工作人员都在忙,大厅座位也满了)于是经理赶紧安排临时工(新创建的线程)在大堂站着,手持pad设备给d客户办理业务; 假如前面的业务都没有结束的时候e客户又来了,此时正式工作人员都上了,临时工也上了,座位也满了(临时工加正式员工的总数量就是最大线程数), 于是经理只能按《超出银行最大接待能力处理办法》(饱和处理机制)拒接接待e客户; 最后,进来办业务的人少了,大厅的临时工空闲时间也超过了1个小时(最大空闲时间),经理就会让这部分空闲的员工人下班.(销毁线程) 但是为了保证银行银行正常工作(有一个allowCoreThreadTimeout变量控制是否允许销毁核心线程,默认false),即使正式工闲着,也不得提前下班,所以1、2号工作人员继续待着(池内保持核心线程数量);

③ 图示解析

④ 案例——秒杀商品

综合案例-秒杀商品 案例介绍: 假如某网上商城推出活动,新上架10部新手机免费送客户体验,要求所有参与活动的人员在规定的时间同时参与秒杀挣抢,假如有20人同时参与了该活动,请使用线程池模拟这个场景,保证前10人秒杀成功,后10人秒杀失败; 要求: 1:使用线程池创建线程 2:解决线程安全问题 思路提示: 1:既然商品总数量是10个,那么我们可以在创建线程池的时候初始化线程数是10个及以下,设计线程池最大数量为10个; 2:当某个线程执行完任务之后,可以让其他秒杀的人继续使用该线程参与秒杀; 3:使用synchronized控制线程安全,防止出现错误数据; 代码步骤: 1:编写任务类,主要是送出手机给秒杀成功的客户; 2:编写主程序类,创建20个任务(模拟20个客户); 3:创建线程池对象并接收20个任务,开始执行任务; 主程序类,测试任务类

任务类

public class Goods implements Runnable{ //定义一个变量，用于存储用户编号 private String name; //有参构造方法，初始化用户编号 public Goods(String name){ this.name=name; } private static int count=10; @Override public void run() { System.out.println(name+"进入了秒杀活动"); if(count>0){ synchronized (Goods.class){ System.out.println(name+"抢到了"+count+"号手机，秒杀成功！"); count--; } }else { System.out.println(name+"秒杀失败"); } } }

主任务类测试

public class Test { public static void main(String[] args) { //创建阻塞队列对象 BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(5); //创建线程池 ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(2,5,6, TimeUnit.SECONDS,workQueue); //循环20个用户 for (int i = 1; i <=20; i++) { //创建任务对象 Goods goods=new Goods("客户"+i); poolExecutor.submit(goods); } } }

⑤ 线程池工作原理

提交任务: 通过execute(Runnable)或submit(Callable<T>)方法提交任务。
任务处理: 核心线程处理任务。如果核心线程已满，任务进入队列。如果队列已满且线程未达到最大线程数，创建新线程处理任
务。如果达到最大线程数，执行拒绝策略。
线程回收: 超过keepAliveTime的空闲线程会被终止，以节省资源。

1.4.5 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

① ArrayBlockingQueue

基于数组的有界队列。

import java.util.concurrent.*; public class ArrayBlockingQueueExample { public static void main(String[] args) throws InterruptedException { // 创建一个容量为3的有界阻塞队列 ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3); // 添加元素到队列中 queue.put(1); queue.put(2); queue.put(3); // 试图添加第四个元素时会阻塞，因为队列已满 new Thread(() -> { try { queue.put(4); System.out.println("Added 4"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); // 让主线程休眠一会儿，以确保子线程被阻塞 Thread.sleep(2000); // 移除队列中的元素 System.out.println("Removed: " + queue.take()); System.out.println("Removed: " + queue.take()); System.out.println("Removed: " + queue.take()); // 现在队列有空间，子线程可以继续执行 } }

② LinkedBlockingQueue

基于链表的无界队列（或指定容量的有界队列）。在未指明容量时，容量默认为 Integer.MAX_VALUE。

import java.util.concurrent.*; public class LinkedBlockingQueueExample { public static void main(String[] args) throws InterruptedException { // 未指定容量时，默认容量为 Integer.MAX_VALUE LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); // 添加元素到队列中 queue.put(1); queue.put(2); queue.put(3); // 移除并打印队列中的元素 System.out.println("Removed: " + queue.take()); System.out.println("Removed: " + queue.take()); System.out.println("Removed: " + queue.take()); } }

③ PriorityBlockingQueue

基于优先级的无界队列，跟时间没有关系，对元素没有要求。可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。

import java.util.concurrent.*; public class PriorityBlockingQueueExample { public static void main(String[] args) throws InterruptedException { PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>(); // 添加元素到队列中 queue.put(5); queue.put(1); queue.put(3); // 移除并打印队列中的元素，按优先级顺序 System.out.println("Removed: " + queue.take()); // 1 System.out.println("Removed: " + queue.take()); // 3 System.out.println("Removed: " + queue.take()); // 5 } }

④ DelayQueue

类似于PriorityBlockingQueue，是二叉堆实现的无界优先级队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。

import java.util.concurrent.*; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; public class DelayQueueExample { public static void main(String[] args) throws InterruptedException { DelayQueue<DelayedElement> queue = new DelayQueue<>(); // 添加延迟元素到队列中 queue.put(new DelayedElement("Element1", 5)); queue.put(new DelayedElement("Element2", 3)); queue.put(new DelayedElement("Element3", 1)); // 移除并打印队列中的元素，按延迟时间 while (!queue.isEmpty()) { System.out.println("Removed: " + queue.take()); } } } class DelayedElement implements Delayed { private final String name; private final long startTime; public DelayedElement(String name, long delayInSeconds) { this.name = name; this.startTime = System.currentTimeMillis() + delayInSeconds * 1000; } @Override public long getDelay(TimeUnit unit) { long diff = startTime - System.currentTimeMillis(); return unit.convert(diff, TimeUnit.MILLISECONDS); } @Override public int compareTo(Delayed o) { if (this.startTime < ((DelayedElement) o).startTime) { return -1; } if (this.startTime > ((DelayedElement) o).startTime) { return 1; } return 0; } @Override public String toString() { return name; } }

⑤ SynchronousQueue

不存储任务的队列，每个插入操作必须等待相应的删除操作。

import java.util.concurrent.*; public class SynchronousQueueExample { public static void main(String[] args) { SynchronousQueue<Integer> queue = new SynchronousQueue<>(); // 创建消费者线程 new Thread(() -> { try { System.out.println("Consumed: " + queue.take()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); // 创建生产者线程 new Thread(() -> { try { queue.put(1); System.out.println("Produced: 1"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); } }

⑥ LinkedBlockingDeque

使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。

import java.util.concurrent.*; public class LinkedBlockingDequeExample { public static void main(String[] args) throws InterruptedException { LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>(3); // 添加元素到双端队列 deque.putFirst(1); deque.putLast(2); deque.putFirst(3); // 从双端队列移除元素 System.out.println("Removed: " + deque.takeFirst()); System.out.println("Removed: " + deque.takeLast()); System.out.println("Removed: " + deque.takeFirst()); } }

⑦ LinkedTransferQueue

它是ConcurrentLinkedQueue、LinkedBlockingQueue和SynchronousQueue的结合体，但是把它用在ThreadPoolExecutor中，和LinkedBlockingQueue行为一致，但是无界的阻塞队列。

import java.util.concurrent.*; public class LinkedTransferQueueExample { public static void main(String[] args) { LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>(); // 创建消费者线程 new Thread(() -> { try { System.out.println("Consumed: " + queue.take()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); // 创建生产者线程 new Thread(() -> { try { queue.transfer(1); System.out.println("Produced and transferred: 1"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }).start(); } }

有界队列和无界队列的区别：
如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

1.4.6 拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。
拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor e) 方法。

Executors 框架为我们实现了 4 种拒绝策略：
AbortPolicy: 直接抛出RejectedExecutionException异常。
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
CallerRunsPolicy: 由提交任务的线程处理该任务。
DiscardPolicy: 丢弃无法处理的任务，不抛出异常。
DiscardOldestPolicy: 丢弃队列中最旧的未处理任务，并尝试重新提交当前任务。

1.5 面试题

execute和submit方法区别？

**相同点：**两个方法都可以向线程池提交任务
**不同点：**execute()方法的返回类型是void，定义在Executor接口中，只能执行Runnable类型的任务
submit()方法可以返回持有计算结果的Future对象，定义在ExecutorService接口中，它扩展了Executor接口，可以执行runnable和callable类型的任务，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。