Executors类创建四种常见线程池

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

}

}

输出结果

线程任务开始执行

pool-1-thread-1 is running…

pool-1-thread-1 is running…

pool-1-thread-2 is running…

pool-1-thread-1 is running…

pool-1-thread-2 is running…

底层实现

/**

• 核心线程池大小=传入参数

• 最大线程池大小为传入参数

• 线程过期时间为0ms

• LinkedBlockingQueue作为工作队列

*/

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

可以看到，FixedThreadPool 的核心线程数和最大线程数都是指定值，也就是说当线程池中的线程数超过核心线程数后，任务都会被放到阻塞队列中。

此外 keepAliveTime 为 0，也就是多余的空余线程会被立即终止（由于这里没有多余线程，这个参数也没什么意义了）。

而这里选用的阻塞队列是 LinkedBlockingQueue，使用的是默认容量 Integer.MAX_VALUE，相当于没有上限。

因此这个线程池执行任务的流程如下：

1. 线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务

2. 线程数等于核心线程数后，将任务加入阻塞队列

3. 由于队列容量非常大，可以一直加

4. 执行完任务的线程反复去队列中取任务执行

FixedThreadPool 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。

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

}

}

输出结果

线程任务开始执行

pool-1-thread-1 is running…

pool-1-thread-4 is running…

pool-1-thread-2 is running…

必看视频！获取2024年最新Java开发全套学习资料 备注Java

pool-1-thread-5 is running…

pool-1-thread-3 is running…

底层实现

/**

• 核心线程池大小=0

• 最大线程池大小为Integer.MAX_VALUE

• 线程过期时间为60s

• 使用SynchronousQueue作为工作队列

*/

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

可以看到，CachedThreadPool 没有核心线程，非核心线程数无上限，也就是全部使用外包，但是每个外包空闲的时间只有 60 秒，超过后就会被回收。

CachedThreadPool 使用的队列是 SynchronousQueue，这个队列的作用就是传递任务，并不会保存。

因此当提交任务的速度大于处理任务的速度时，每次提交一个任务，就会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。

它的执行流程如下：

1. 没有核心线程，直接向 SynchronousQueue 中提交任务

2. 如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个

3. 执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续活下去，否则就拜拜

4. 由于空闲 60 秒的线程会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。

CachedThreadPool 用于并发执行大量短期的小任务，或者是负载较轻的服务器。

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(“线程任务开始执行”);

}

}

输出结果

线程任务开始执行

// 打印【线程任务开始执行】后1秒输出

pool-1-thread-1 is running…

pool-1-thread-2 is running…

pool-1-thread-1 is running…

pool-1-thread-3 is running…

pool-1-thread-2 is running…

// 2秒后输出

pool-1-thread-1 is running…

pool-1-thread-3 is running…

pool-1-thread-2 is running…

pool-1-thread-1 is running…

pool-1-thread-3 is running…

底层实现

/**

• 核心线程池大小=传入参数

• 最大线程池大小为Integer.MAX_VALUE

• 线程过期时间为0ms

• DelayedWorkQueue作为工作队列

*/

public ScheduledThreadPoolExecutor(int corePoolSize) {

super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,

new DelayedWorkQueue());

}

ScheduledThreadPoolExecutor 的执行流程如下：

1. 添加一个任务

2. 线程池中的线程从 DelayQueue 中取任务

3. 然后执行任务

具体执行任务的步骤也比较复杂：

1. 线程从 DelayQueue 中获取 time 大于等于当前时间的 ScheduledFutureTask

2. 执行完后修改这个 task 的 time 为下次被执行的时间

3. 然后再把这个 task 放回队列中

ScheduledThreadPoolExecutor 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。

Executors和ThreaPoolExecutor创建线程池的区别

---

Executors 各个方法的弊端：

1. newFixedThreadPool 和 newSingleThreadExecutor:

主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM。

2. newCachedThreadPool 和 newScheduledThreadPool:

主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。

ThreaPoolExecutor

1. 创建线程池方式只有一种，就是走它的构造函数，参数自己指定

两种提交任务的方法

---

ExecutorService 提供了两种提交任务的方法：

• execute()：提交不需要返回值的任务

• submit()：提交需要返回值的任务

execute

void execute(Runnable command);

execute() 的参数是一个 Runnable，也没有返回值。因此提交后无法判断该任务是否被线程池执行成功。

ExecutorService executor = Executors.newCachedThreadPool();

executor.execute(new Runnable() {

@Override

public void run() {

//do something

}

});

submit

Future submit(Callable task);

Future submit(Runnable task, T result);

Future<?> submit(Runnable task);

submit() 有三种重载，参数可以是 Callable 也可以是 Runnable。

同时它会返回一个 Funture 对象，通过它我们可以判断任务是否执行成功。

获得执行结果调用 Future.get() 方法，这个方法会阻塞当前线程直到任务完成。

提交一个 Callable 任务时，需要使用 FutureTask 包一层：

FutureTask futureTask = new FutureTask(new Callable() { //创建 Callable 任务

@Override

public String call() throws Exception {

String result = “”;

//do something

return result;

}

});

Future<?> submit = executor.submit(futureTask); //提交到线程池

try {

Object result = submit.get(); //获取结果

} catch (InterruptedException e) {

e.printStackTrace();

最后

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

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

最新整理电子书

) { //创建 Callable 任务

@Override

public String call() throws Exception {

String result = “”;

//do something

return result;

}

});

Future<?> submit = executor.submit(futureTask); //提交到线程池

try {

Object result = submit.get(); //获取结果

} catch (InterruptedException e) {

e.printStackTrace();

最后

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

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

[外链图片转存中…(img-lsC0Lh5N-1716471064158)]

最新整理电子书

[外链图片转存中…(img-4eF4oF8e-1716471064159)]