关于Java线程池ThreadPoolExecutor相关介绍(2)，2024年最新mysql面试题大全

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

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

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

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

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

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

正文

Executors 其实是个工具类，里面提供了好多静态方法，这些方法根据用户选择返回不同的线程池实例。ThreadPoolExecutor 继承了 AbstractExecutorService，成员变量 ctr 是一个 Integer 的原子变量，用来记录线程池状态和线程池中线程个数。

这里假设 Integer 类型是32位二进制表示，则其中高 3 位用来表示线程池状态，后面 29 位用来记录线程池线程个数。

//（ 高3位）用来表示线程池状态，（低29位）用来表示线程个数

// 默认是RUNNING状态，线程个数为0

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)) ;

// 线程个数掩码位数，并不是所有平台的int类型都是32位的，所以准确地说，是具体平台下Integer二进制位数-3后的剩余位数所表示的数才是线程的个数

private static final int COUNT_BITS = Integer.SIZE - 3 ;

// 线程最大个数（低29位） 00011111111111111111111111111111

private static final int CAPACITY = (1 << COUNT_BITS) - 1 ;

线程池状态:

//（高3位） : 11100000000000000000000000000000

private static final int RUNNING = -1 << COUNT_BITS;

// (高3主） : 00000000000000000000000000000000

private static final int SHUTDOWN = 0 << COUNT_BITS ;

//（高3位） : 00100000000000000000000000000000

private static final int STOP = 1 < COUNT BITS ;

//（高3位） : 01000000000000000000000000000000

private static final int TIDYING = 2 < COUNT BITS;

//（高3位） : 01100000000000000000000000000000

private static final int TERMINATED = 3 < COUNT_BITS;

// 获取高3位（运行状态）

private static int runStateOf(int c) { return c & ~CAPACITY ; }

// 获取低29位（线程个数）

private static int workerCountOf(int c) { return c & CAPACITY ; }

// 计算ctl新值（线程状态与线程个数）

private static int ctlOf (int rs, int we) { return rs | we; }

线程池状态含义如下。

• RUNNING： 接受新任务并且处理阻塞队列里的任务。

• SHUTDOWN： 拒绝新任务但是处理阻塞队列里的任务。

• TIDYING： 所有任务都执行完（包含阻塞队列里面的任务）后当前线程池数为 0，将要调用terminated方法。

• TERMINATED： 终止状态。terminated 方法调用完成以后的状态。

• RUNNING -> SHUTDOWN: 显式调用 shutdown() 方法，或者隐式调用了 finalize() 方法里面的 shutdown() 方法。

• RUNNING 或 SHUTDOWN -> STOP： 显式调用 shutdownNow() 方法时。

• SHUTDOWN -> TIDYING： 当线程池任务队列都为空时。

• STOP -> TIDYING： 当线程池为空时。

• TIDYING -> TERMINATED： 当 terminated() hook 方法执行完成时。

线程池参数如下。

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

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

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

• ThreadFactory： 创建线程工厂。

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

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

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

线程池的创建方式

===========================================================================

线程池的创建方式总共包含以下 7 种，（其中 6 钟是通过 Executors 自动创建的，1 种是通过 ThreadPoolExecutor 手动创建的。）

1. newFixedThreadPool 创建固定线程数量的线程池

---

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

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

• 创建一个固定大小的线程池

*/

public class ThreadPoolDemo1 {

public static void main(String[] args) {

// 创建一个线程个数为5的固定大小的线程池

ExecutorService threadPool = Executors.newFixedThreadPool(5);

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

threadPool.submit(new Runnable() {

@Override

public void run() {

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

}

});

// 使用线程池执行任务2

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

// 给线程池添加任务

threadPool.execute(new Runnable() {

@Override

public void run() {

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

}

});

}

}

}

执行结果：

从以上代码我们可以看到，使用Executors.newFixedThreadPool() 方法，传递一个整型参数，此时系统就会自动帮我们创建固定数量的线程，此处我们创建了五个线程，通过 JVM 我们也可以观察到我们创建的线程池中包含有五个新创建好等待工作的线程，当我们有工作任务时，就可以直接从线程池中拿出线程去用。

threadPool.submit() 和threadPool.execute() 的区别

使用 submit 它可以执行有返回值的任务或者是无返回值的任务；而 execute 只能执行不带返回值的任务。

线程池有返回值实现：

import java.util.Random;

import java.util.concurrent.*;

/**

• 演示有返回值的线程池

*/

public class ThreadPoolDemo2 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

// 创建一个线程个数为5的固定大小的线程池

ExecutorService threadPool = Executors.newFixedThreadPool(5);

Future result = threadPool.submit(new Callable() {

@Override

public Integer call() throws Exception {

int num = new Random().nextInt(10);

System.out.println(“生成随机数：” + num);

return num;

}

});

System.out.println(“得到线程池返回结果：” + result.get());

}

}

线程池中的工厂

我们创建一个线程池，无疑是要创建很多线程的，那线程池在创建线程的时候，也是需要给线程有一个明确的标准的，需要给线程提供相关的参数，那么这个给线程池创建添加线程的过程，就是需要线程工厂来完成的。

我们可以看一下 JDK 给我们提供的默认线程池的定义方式：

如果我们自己不设置线程工厂，线程池就会使用默认的线程工厂来创建线程。

下面我们来自己设置一个线程工厂：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadFactory;

import static java.lang.Thread.MAX_PRIORITY;

public class ThreadPoolDemo3_线程工厂演示 {

public static void main(String[] args) {

// 1. 创建线程工厂

ThreadFactory factory = new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

// 一定要把Runnable设置给新创建的线程

Thread thread = new Thread®;

// 设置线程的命名规则

thread.setName(“->” + r.hashCode());

// 设置线程优先级

thread.setPriority(MAX_PRIORITY);

return thread;

}

};

ExecutorService service = Executors.newFixedThreadPool(5,factory);

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

service.submit(new Runnable() {

@Override

public void run() {

// 任务来了

System.out.println(“我的” + Thread.currentThread().getName()+“号线程开始执行任务”);

}

});

}

}

}

执行效果：

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

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<>()

总结

面试建议是，一定要自信，敢于表达，面试的时候我们对知识的掌握有时候很难面面俱到，把自己的思路说出来，而不是直接告诉面试官自己不懂，这也是可以加分的。

以上就是蚂蚁技术四面和HR面试题目，以下最新总结的最全，范围包含最全MySQL、Spring、Redis、JVM等最全面试题和答案，仅用于参考

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

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

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

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

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

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

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

总结

面试建议是，一定要自信，敢于表达，面试的时候我们对知识的掌握有时候很难面面俱到，把自己的思路说出来，而不是直接告诉面试官自己不懂，这也是可以加分的。

以上就是蚂蚁技术四面和HR面试题目，以下最新总结的最全，范围包含最全MySQL、Spring、Redis、JVM等最全面试题和答案，仅用于参考

[外链图片转存中…(img-n79haUfo-1713683496776)]

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

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

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