关于Java线程池ThreadPoolExecutor相关介绍，java面试宝典下载

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

});

}

}

}

执行效果：

我们通过自己定义线程工厂来创建线程，线程工厂提供的功能有：

1. 设置（线程池中的）线程的命名规则

2. 设置线程的优先级

3. 设置线程的分组

4. 设置线程类型（用户线程&守护线程）、

2. newCachedThreadPool 带缓存的线程池

---

创建一个按需创建的线程池，初始线程个数为 0，最多线程个数为 Integer.MAX_VALUE，并且阻塞队列为同步队列。keeyAliveTime=60 说明只要当前线程在 60s 内空闲则回收。这个类型的特殊之处在，加入同步队列的任务会被马上执行，同步队列里面最多只有一个任务。

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

• 线程池用法2：带缓存的线程池

*/

public class ThreadPoolDemo4 {

public static void main(String[] args) {

// 创建带缓存的线程池

ExecutorService service = Executors.newCachedThreadPool();

for (int i = 0; i < 1000; i++) {

int finalI = i;

service.submit(() -> {

System.out.println(“i：”+ finalI +“|线程名称”+Thread.currentThread().getName());

});

}

}

}

运行结果：

因为只要不结束这个线程池任务销毁线程池，在线程池中创建的线程是不会在执行一次任务结束时自动销毁的，而是会缓存起来，等待其他的任务加入以便再次复用线程。带缓存的线程池比较适用的场景是突发的带有大量任务的情况下使用这种方式会比较合适，因为它可以根据任务量来帮你分配线程数并且对资源的分配也相对比较合适。

3. newScheduledThreadPool 执行定时任务的线程池

---

这个执行定时任务的线程池我们主要了解 schedule 方法的三个参数的意义就可以掌握这个方法，我们进入这个方法内部：

schedule方法： 延迟执行一次定时任务；

long delay 参数：延迟多久进行执行；

TimtUnit unit 参数：对参数2 的时间单位描述。

事例：

import java.time.LocalDateTime;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

• 创建执行定时任务的线程池

*/

public class ThreadPoolDemo5 {

public static void main(String[] args) {

// 创建线程池

ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

System.out.println(“添加任务的时间：” + LocalDateTime.now());

// 执行定时任务

service.schedule(new Runnable() {

@Override

public void run() {

System.out.println(“执行任务：” + LocalDateTime.now());

}

},3, TimeUnit.SECONDS);

}

}

执行结果：

成功执行了一次定时任务。接下来我们看如何执行多次定时任务及两个执行多次任务方法的区别。

scheduleAtFixedRate 以上一次任务的开始时间作为开始时间计算延迟任务的执行时间

// 2s 之后开始执行定时任务，定时任务每隔4s 执行一次

service.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println(“执行任务：” + LocalDateTime.now());

}

},2,4,TimeUnit.SECONDS);

scheduleAtFixedRate注意事项：

如果执行任务的时间大于设定的任务执行时间间隔，比如，我们的任务间隔参数设置为 2s 但是在任务中含有一个 sleep(3000) 的休眠时间。那么此方法会以任务执行的时间为定时任务的间隔周期来执行。也就是说，哪个值大就是用哪个值作为定时任务的执行周期。

scheduleWithFixedRate 以上一次任务的结束时间作为开始时间计算延迟任务的执行时间

演示这个方法，以下我们设置了一个时间间隔为 4s 的线程池，但是在每一个任务中我们会有一个 sleep(1000) 休眠 1s 的任务。

service.scheduleWithFixedDelay(new Runnable() {

@Override

public void run() {

System.out.println(“执行任务：” + LocalDateTime.now());

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

},2,4,TimeUnit.SECONDS);

执行结果：

4. newSingleThreadScheduledExecutor 执行定时任务的单线程线程池

---

这种线程创建方式相当于第三种创建方式创建单个线程。

import java.time.LocalDateTime;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo6 {

public static void main(String[] args) {

// 创建执行定时任务的单线程线程池

ScheduledExecutorService service =

Executors.newSingleThreadScheduledExecutor();

System.out.println(“添加任务时间” + LocalDateTime.now());

service.schedule(new Runnable() {

@Override

public void run() {

System.out.println(“执行任务时间：” + LocalDateTime.now());

}

},2, TimeUnit.SECONDS);

}

}

执行结果：

5. newSingleThreadExecutor 单线程线程池

---

创建一个核心线程个数和最大线程个数都为 1 的线程池，并且阻塞队列长度为 Integer.MAX_VALUE。keeyAliveTime=0 说明只要线程个数比核心线程个数多并且当前空闲则回收。

import java.time.LocalDateTime;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolDemo7 {

public static void main(String[] args) {

ExecutorService service = Executors.newSingleThreadExecutor();

for (int i = 0; i < 10; i++) {

service.submit(new Runnable() {

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(LocalDateTime.now() +“-线程名” + Thread.currentThread().getName());

}

});

}

}

}

执行结果：

从结果可以看到，单线程的线程池就只会产生一个线程所有任务都使用这一个线程执行。

为什么不直接使用线程，单线程的线程池有什么意义？

1. 虽然是单线程的线程池，但是它不会频繁的创建和销毁线程，只要线程池没有被结束销毁，就可以一直复用这个线程。

2. 单线程的线程池也是提供了任务队列和拒绝策略的，当这个线程在执行其他任务时，新加进来的任务会被排队放在任务队列中等待被执行，当任务队列也都放满的时候，线程池就会友好的执行拒绝策略。

3. 所以说，如果使用了线程池，无论有多少的任务，哪怕线程池只有一个线程，也都会有效的将这些任务都完成执行的。但是线程就不行了。

单线程线程池任务队列保证先进先出原则

任务队列底层实现是我使用了：LinkedBlockingQueue<>()

public static void main(String[] args) {

ExecutorService service = Executors.newSingleThreadExecutor();

for (int i = 0; i < 10; i++) {

int finalI = i;

service.submit(new Runnable() {

@Override

public void run() {

System.out.println(“任务：”+ finalI +“-线程名” + Thread.currentThread().getName());

}

});

}

}

执行结果：

6. newWorkStealingPool 根据当前CPU生成线程池

---

这种线程池的创建方式是 JDK1.8 才提供的，它是会根据当前的 CPU 资源，根据你的运行程序的电脑配置，来生成相应的线程个数的。

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ThreadPoolDemo8 {

public static void main(String[] args) {

//根据当前设备的配置自动生成线程池

ExecutorService service = Executors.newWorkStealingPool();

for (int i = 0; i < 100; i++) {

service.submit(() -> {

System.out.println(“线程名” + Thread.currentThread().getName());

});

}

while (!service.isTerminated()) {

}

}

}

执行结果：

我们启动了100个任务，从运行结果找出最大的线程数，发现线程池为我们创建了 0-7 共 8 个线程，这是因为我所使用的设备配置 CPU 是八核的，newWorkStealingPool 这种创建方式也就根据设备配置提供了相应的线程数。

7. ThreadPoolExecutor 手动方式创建线程池

---

Executors 自动创建线程池可能存在的问题

以下是阿里巴巴开发手册里面的规定：

也就是说，使用自动创建线程池的方式，在海量任务量的业务处理中，因为这种自动创建方式任务队列的大小是 Integer.MAX_VALUE 是无限大的，那么就可能存在资源耗尽的风险，在程序中就是可能会导致内存溢出。而我们选择手动创建线程池就可以根据自己的内存情况手动设置任务队列和拒绝策略的参数，以避免内存溢出或程序崩溃。

ThreadPoolExecutor 使用

1. 参数种类

2. 参数解释

3. 代码示例

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo9 {

public static void main(String[] args) {

ThreadFactory factory = new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

Thread thread = new Thread®;

return thread;

}

};

// 手动方式创建线程池

ThreadPoolExecutor executor =

new ThreadPoolExecutor(5,10,10, TimeUnit.SECONDS,

new LinkedBlockingQueue<>(100),factory,

new ThreadPoolExecutor.DiscardPolicy());

for (int i = 0; i < 10; i++) {

executor.submit(() -> {

System.out.println(“线程名称：” + Thread.currentThread().getName());

});

}

}

}

执行效果：

以上代码，创建了一个含有 5 个核心线程，最大线程数为 10 ，闲置线程最大存活时间为 10s 的线程池。需要注意的是，我们对于参数 workQueue ，一定要给任务队列设置大小，这是手动创建线程池最大的不同于自动创建线程池的规范。

线程池参数说明

• corePoolSize： 线程池核心线程个数。

• workQueue： 用于保存等待执行的任务阻塞队列，比如基于数组的有界 ArrayBlockingQueue、基于链表的无界 LinkedBlockingQueue、最多只有一个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue 等。

• maximunPoolSize： 线程池最大线程数量。

• ThreadFactory： 创建线程工厂。

• RejectedExecutionHandler： 饱和策略，当队列满并且线程个数达到 maximunPoolSize 后采取的策略，比如 AbortPolicy（抛出异常）、CallerRunsPolicy（使用调用者所在线程来运行任务）、DiscardOldestPolicy（调用 poll 丢弃一个任务，执行当前任务）及 DiscardPolicy（默默丢弃，不抛出异常）

• keeyAliveTime： 存活时间。如果当前线程池中的线程数量比核心线程数量多，并且是闲置状态，则这些闲置的线程能存活的最大时间。

• TimeUnit： 存活时间的时间单位。

线程池执行流程+线程池重要执行节点

这里有一个面试问题：

为什么在线程池执行流程中，当任务数大于核心线程数时，是先判断阻塞队列是否已满，如果阻塞队列没有满是先将任务放进阻塞队列等待执行，而不是直接判断当前线程数是否小于最大线程数去直接创建线程执行的。

我们需要了解的是：线程池的执行机制是会延迟创建线程的，那么为什么会选择延迟创建，这是和线程池资源利用的策略有关系的，也就是并不是在创建线程池时候直接创建好核心线程数量的线程的，而是在有任务来了之后，线程工厂才会根据任务需要去创建线程，而先进行任务队列的判断也就是为了保证资源利用的最大化和开销的最小化。

线程池重要执行节点：

1. 当任务来了之后，判断线程池中实际线程数是否小于核心线程数，如果小于就直接创建线程并执行任务。

2. 当实际线程数大于核心线程数，他会判断任务队列是否已满，如果未满直接将任务存放队列即可。

3. 判断线程池的实际线程数是否大于最大线程数，如果小于最大线程数直接创建线程执行任务；实际线程

线程池拒绝策略（4+1）

• CallerRunsPolicy： 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然损失较大。

• AbortPolicy： 直接丢弃，当抛出拒绝执行 RejectExcutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。

• DiscardPolicy： 直接丢弃，其他啥都没有

• DiscardOldestPolicy： 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入。

示例代码：

public static void main(String[] args) {

ThreadFactory factory = new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

Thread thread = new Thread®;

return thread;

}

};

// 手动方式创建线程池

ThreadPoolExecutor executor =

new ThreadPoolExecutor(2, 2, 10, TimeUnit.SECONDS,

new LinkedBlockingQueue<>(2), factory,

new ThreadPoolExecutor.AbortPolicy());

for (int i = 0; i < 5; i++) {

int finalI = i;

executor.submit(() -> {

try {

Thread.sleep(100 * finalI);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + “——执行任务：” + finalI);

});

}

// 终止线程

executor.shutdownNow();

}

现象：

• 核心线程数为 2 ，最大线程数为 2，阻塞队列容量为 2。

• AbortPolicy

直接报异常。

• DiscardPolicy

不报异常，但也不执行第五个任务。

• DiscardOldestPolicy

忽略任务队列第一个任务不执行，执行新任务。

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

不报异常，但也不执行第五个任务。

• DiscardOldestPolicy

忽略任务队列第一个任务不执行，执行新任务。

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

[外链图片转存中…(img-9R0GlgMX-1713683521645)]

上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

[外链图片转存中…(img-UPVLcwqq-1713683521646)]

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-0AoFWGgI-1713683521646)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！