文章目录
为什么要使用线程池
使用线程池的主要原因有:
- 资源优化:创建和销毁线程需要消耗系统资源,使用线程池可以复用已经创建的线程,减少开销。
- 控制并发:可以控制同时运行的线程数量,避免因过多并发导致系统资源耗尽。
- 统一管理:线程池可以对线程进行统一管理,简化并发编程。
ThreadPoolExecutor
Java中的线程池由Executor
接口定义,ThreadPoolExecutor
是其最常见的实现。
ThreadPoolExecutor
的构造方法涉及以下参数:
构造方法解析
ThreadPoolExecutor
有四个构造方法,涉及5到7个参数,其中最重要的5个参数是:
// 五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)
// 六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
// 六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
// 七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
-
corePoolSize
:核心线程数,核心线程即使空闲也不会被销毁。 -
maximumPoolSize
:线程池最大线程数,包含核心和非核心线程。 -
keepAliveTime
:非核心线程的闲置超时时间,超过该时间则被销毁。如果设置allowCoreThreadTimeOut(true)
,则会也作用于核心线程 -
unit
:时间单位,决定keepAliveTime
的时间单位。 -
workQueue
:阻塞队列,用于存储等待执行的任务。常用的几个阻塞队列:
-
LinkedBlockingQueue
链式阻塞队列,底层数据结构是链表,默认大小是
Integer.MAX_VALUE
,也可以指定大小。 -
ArrayBlockingQueue
数组阻塞队列,底层数据结构是数组,需要指定队列的大小。
-
SynchronousQueue
同步队列,内部容量为0,每个put操作必须等待一个take操作,反之亦然。
-
DelayQueue
延迟队列,该队列中的元素只有当其指定的延迟时间到了,才能够从队列中获取到该元素 。
-
另外,两个可选参数是:
-
threadFactory
:创建线程的工厂,允许自定义线程的创建方式。创建线程的工厂 ,用于批量创建线程,统一在创建线程时设置一些参数,如是否守护线程、线程的优先级等。如果不指定,会新建一个默认的线程工厂。
static class DefaultThreadFactory implements ThreadFactory { // 省略属性 // 构造函数 DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } // 省略 }
-
handler
:拒绝策略,当任务无法被处理时执行。拒绝处理策略,线程数量大于最大线程数就会采用拒绝处理策略,四种拒绝处理的策略为 :
-
ThreadPoolExecutor.AbortPolicy:默认拒绝处理策略,丢弃任务并抛出RejectedExecutionException异常。
-
ThreadPoolExecutor.DiscardPolicy:丢弃新来的任务,但是不抛出异常。
-
ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列头部(最旧的)的任务,然后重新尝试执行程序(如果再次失败,重复此过程)。
-
ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务。
-
常见的阻塞队列实现及其特性
Java的java.util.concurrent
包中提供了几种常见的阻塞队列实现:
-
ArrayBlockingQueue:
- 特点:基于数组的有界阻塞队列,容量固定,使用一个锁(ReentrantLock)控制所有操作。
- 适用场景:适合生产者和消费者数量较为均衡的场景,且队列容量需要明确限制的情况下使用。
-
LinkedBlockingQueue:
- 特点:基于链表的阻塞队列,可以是有界的(指定容量)或者无界的(容量为
Integer.MAX_VALUE
),入队和出队操作分别使用不同的锁,因此并发性能较好。 - 适用场景:适用于生产者和消费者不均衡,或者希望队列可以动态扩展容量的场景。
- 特点:基于链表的阻塞队列,可以是有界的(指定容量)或者无界的(容量为
-
PriorityBlockingQueue:
- 特点:基于优先级的无界阻塞队列,元素会按照自然顺序或者指定的比较器顺序排列。
- 适用场景:适合需要按照优先级处理任务的场景,比如任务调度系统。
-
DelayQueue:
- 特点:无界阻塞队列,元素在放入队列时会指定一个延迟时间,只有延迟时间到达后才能被取出。
- 适用场景:适用于任务延迟执行的场景,比如定时任务调度。
-
SynchronousQueue:
- 特点:一个特殊的队列,它没有容量,每一个插入操作必须等待一个相应的移除操作,反之亦然。
- 适用场景:适合任务提交非常频繁,且任务处理时间较短的场景,典型的应用是在线程池中直接将任务从生产者交给消费者。
阻塞队列在实际应用中的适用场景分析
- ArrayBlockingQueue在日志处理系统中可以用来实现一个固定大小的日志缓冲区,避免过多日志占用系统资源。
- LinkedBlockingQueue则适合应用在任务处理较多、峰值流量不可预估的场景,比如处理Web请求。
- PriorityBlockingQueue可以用于任务调度器或工作流引擎中,确保高优先级的任务先被处理。
- DelayQueue常用于实现延时任务或定时任务,比如在订单系统中处理延时支付。
- SynchronousQueue则在高并发环境下非常有用,比如在高效的消息传递系统中作为核心机制。
自定义ThreadFactory和RejectedExecutionHandler
自定义ThreadFactory
和RejectedExecutionHandler
可以增强线程池的功能。
-
ThreadFactory:
- 概念:
ThreadFactory
接口提供了一种创建新线程的机制。自定义的ThreadFactory
可以用于设置线程名称、优先级、是否守护线程等属性。 - 使用场景:当你希望每个线程在创建时都具有特定的属性,比如命名为特定前缀以便调试,或者为线程设置不同的优先级以处理不同的任务。
public class CustomThreadFactory implements ThreadFactory { private final AtomicInteger threadNumber = new AtomicInteger(1); private final String namePrefix; public CustomThreadFactory(String namePrefix) { this.namePrefix = namePrefix; } @Override public Thread newThread(Runnable r) { Thread t = new Thread(r, namePrefix + "-thread-" + threadNumber.getAndIncrement()); t.setPriority(Thread.NORM_PRIORITY); return t; } }
- 概念:
-
RejectedExecutionHandler:
- 概念:
RejectedExecutionHandler
接口定义了当线程池无法处理新的任务时所采取的策略。内置的策略包括AbortPolicy
(抛出异常)、DiscardPolicy
(丢弃任务)、DiscardOldestPolicy
(丢弃最旧的任务)以及CallerRunsPolicy
(由调用线程执行任务)。 - 使用场景:当任务提交量超过线程池的处理能力时,使用自定义的拒绝策略可以实现更细致的控制,比如将任务移至另一个线程池,或者记录日志以备后续处理。
public class CustomRejectedExecutionHandler implements RejectedExecutionHandler { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { // Log the rejected task System.out.println("Task rejected: " + r.toString()); // Implement custom handling logic here } }
- 概念:
实际使用中的示例与代码片段
一个使用自定义ThreadFactory
和RejectedExecutionHandler
创建线程池的示例:
ThreadFactory threadFactory = new CustomThreadFactory("MyPool");
RejectedExecutionHandler rejectionHandler = new CustomRejectedExecutionHandler();
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, 4, 10, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(2), threadFactory, rejectionHandler);
for (int i = 0; i < 10; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName() + " is executing");
});
}
executor.shutdown();
CustomThreadFactory
设置了线程的名称前缀,而CustomRejectedExecutionHandler
处理被拒绝的任务。
线程池的状态
ThreadPoolExecutor
通过ctl
变量(一个AtomicInteger
类型)管理线程池的状态。状态包括:
- RUNNING:正常运行状态,可以接受新任务。
- SHUTDOWN:调用
shutdown()
后,不能接受新任务,但会执行队列中的任务。 - STOP:调用
shutdownNow()
后,立即停止所有任务,丢弃未处理的任务。 - TIDYING:所有任务已终止且线程数为0时进入此状态。
- TERMINATED:执行
terminated()
后进入终止状态。
线程池本身有一个调度线程,这个线程就是用于管理布控整个线程池里的各种任务和事务,例如创建线程、销毁线程、任务队列管理、线程队列管理等等。
故线程池也有自己的状态。ThreadPoolExecutor
类中使用了一些final int
常量变量来表示线程池的状态 ,分别为RUNNING、SHUTDOWN、STOP、TIDYING 、TERMINATED。
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
-
线程池创建后处于RUNNING状态。
-
调用shutdown()方法后处于SHUTDOWN状态,线程池不能接受新的任务,清除一些空闲worker,不会等待阻塞队列的任务完成。
-
调用shutdownNow()方法后处于STOP状态,线程池不能接受新的任务,中断所有线程,阻塞队列中没有被执行的任务全部丢弃。此时,poolsize=0,阻塞队列的size也为0。
-
当所有的任务已终止,ctl记录的”任务数量”为0,线程池会变为TIDYING状态。接着会执行terminated()函数。
ThreadPoolExecutor中有一个控制状态的属性叫
ctl
,它是一个AtomicInteger类型的变量。线程池状态就是通过AtomicInteger类型的成员变量ctl
来获取的。获取的
ctl
值传入runStateOf
方法,与~CAPACITY
位与运算(CAPACITY
是低29位全1的int变量)。~CAPACITY
在这里相当于掩码,用来获取ctl的高3位,表示线程池状态;而另外的低29位用于表示工作线程数 -
线程池处在TIDYING状态时,执行完terminated()方法之后,就会由 TIDYING -> TERMINATED, 线程池被设置为TERMINATED状态。
线程池的任务处理流程
ThreadPoolExecutor
的核心方法是execute
,
// JDK 1.8
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程执行任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 2.如果不小于corePoolSize,则将任务添加到workQueue队列。
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 2.1 如果isRunning返回false(状态检查),则remove这个任务,然后执行拒绝策略。
if (! isRunning(recheck) && remove(command))
reject(command);
// 2.2 线程池处于running状态,但是没有线程,则创建线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 3.如果放入workQueue失败,则创建非核心线程执行任务,
// 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时),就会执行拒绝策略。
else if (!addWorker(command, false))
reject(command);
}
ctl.get()
是获取线程池状态,用int
类型表示。第二步中,入队前进行了一次isRunning
判断,入队之后,又进行了一次isRunning
判断。
其任务处理流程如下:
- 添加到核心线程:如果线程数少于
corePoolSize
,创建新的核心线程执行任务。 - 入队任务:如果线程数已达
corePoolSize
,将任务加入workQueue
。 - 非核心线程处理:如果队列已满且线程数未达
maximumPoolSize
,创建非核心线程执行任务。 - 拒绝策略:如果任务无法处理,则执行拒绝策略。
为什么要二次检查线程池的状态?
在多线程的环境下,线程池的状态是时刻发生变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将command
加入workqueue
是线程池之前的状态。倘若没有二次检查,万一线程池处于非RUNNING状态(在多线程环境下很有可能发生),那么command
永远不会执行。
处理流程
线程总数量 < corePoolSize
,无论线程是否空闲,都会新建一个核心线程执行任务(让核心线程数量快速达到corePoolSize,在核心线程数量 < corePoolSize时)。注意,这一步需要获得全局锁。线程总数量 >= corePoolSize
时,新来的线程任务会进入任务队列中等待,然后空闲的核心线程会依次去缓存队列中取任务来执行(体现了线程复用)。- 当
缓存队列满
了,说明这个时候任务已经多到爆棚,需要一些“临时工”来执行这些任务了。于是会创建非核心线程去执行这个任务。注意,这一步需要获得全局锁。 缓存队列满了, 且总线程数达到了maximumPoolSize
,则会采取上面提到的拒绝策略进行处理。
线程复用的实现
线程池通过Worker
类实现线程的复用。Worker
类是Runnable
的实现,在被创建时绑定一个线程。这个Worker
对象会不断从阻塞队列中取任务并执行,直到队列为空或线程池被关闭,从而实现线程的复用。
- addWorker方法:用于添加新的
Worker
对象(即新的线程)。 - runWorker方法:
Worker
对象在启动后会执行这个方法,循环获取并执行任务,直到任务队列为空。
// ThreadPoolExecutor.addWorker方法源码上半部分
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
// 1.如果core是ture,证明需要创建的线程为核心线程,则先判断当前线程是否大于核心线程
// 如果core是false,证明需要创建的是非核心线程,则先判断当前线程数是否大于总线程数
// 如果不小于,则返回false
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
上半部分主要是判断线程数量是否超出阈值,超过了就返回false
我们继续看下半部分:
// ThreadPoolExecutor.addWorker方法源码下半部分
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 1.创建一个worker对象
w = new Worker(firstTask);
// 2.实例化一个Thread对象
final Thread t = w.thread;
if (t != null) {
// 3.线程池全局锁
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 4.启动这个线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
创建worker
对象,并初始化一个Thread
对象,然后启动这个线程对象。
我们接着看看Worker
类,仅展示部分源码:
// Worker类部分源码
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
final Thread thread;
Runnable firstTask;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
//其余代码略...
}
Worker
类实现了Runnable
接口,所以Worker
也是一个线程任务。在构造方法中,创建了一个线程,线程的任务就是自己。故addWorker
方法调用addWorker方法源码下半部分中的第4步t.start
,会触发Worker
类的run
方法被JVM调用。
我们再看看runWorker
的逻辑:
// Worker.runWorker方法源代码
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 1.线程启动之后,通过unlock方法释放锁
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 2.Worker执行firstTask或从workQueue中获取任务,如果getTask方法不返回null,循环不退出
while (task != null || (task = getTask()) != null) {
// 2.1进行加锁操作,保证thread不被其他线程中断(除非线程池被中断)
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 2.2检查线程池状态,倘若线程池处于中断状态,当前线程将中断。
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 2.3执行beforeExecute
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 2.4执行任务
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
// 2.5执行afterExecute方法
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
// 2.6解锁操作
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
首先去执行创建这个worker时就有的任务,当执行完这个任务后,worker的生命周期并没有结束,在while
循环中,worker会不断地调用getTask
方法从阻塞队列中获取任务然后调用task.run()
执行任务,从而达到复用线程的目的。只要getTask
方法不返回null
,此线程就不会退出。
当然,核心线程池中创建的线程想要拿到阻塞队列中的任务,先要判断线程池的状态,如果STOP或者TERMINATED,返回null
。
最后看看getTask
方法的实现:
// Worker.getTask方法源码
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// 1.allowCoreThreadTimeOut变量默认是false,核心线程即使空闲也不会被销毁
// 如果为true,核心线程在keepAliveTime内仍空闲则会被销毁。
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 2.如果运行线程数超过了最大线程数,但是缓存队列已经空了,这时递减worker数量。
// 如果有设置允许线程超时或者线程数量超过了核心线程数量,
// 并且线程在规定时间内均未poll到任务且队列为空则递减worker数量
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 3.如果timed为true(想想哪些情况下timed为true),则会调用workQueue的poll方法获取任务.
// 超时时间是keepAliveTime。如果超过keepAliveTime时长,
// poll返回了null,上边提到的while循序就会退出,线程也就执行完了。
// 如果timed为false(allowCoreThreadTimeOut为false
// 且wc > corePoolSize为false),则会调用workQueue的take方法阻塞在当前。
// 队列中有任务加入时,线程被唤醒,take方法返回任务,并执行。
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
核心线程的会一直卡在workQueue.take
方法,被阻塞并挂起,不会占用CPU资源,直到拿到Runnable
然后返回(当然如果allowCoreThreadTimeOut设置为true
,那么核心线程就会去调用poll
方法,因为poll
可能会返回null
,所以这时候核心线程满足超时条件也会被销毁)。
非核心线程会workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)
,如果超时还没有拿到,下一次循环判断compareAndDecrementWorkerCount就会返回null
,Worker对象的run()
方法循环体的判断为null
,任务结束,然后线程被系统回收 。
四种常见的线程池
Executors
类提供了几种常见的线程池,方便开发者根据需求快速创建不同类型的线程池。
以下是这四种线程池的实现及其运行流程:
newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
运行流程:
- 提交任务到线程池。
- 由于
corePoolSize
为0,不会创建核心线程。线程池最大线程数为Integer.MAX_VALUE
。 - 任务被尝试添加到
SynchronousQueue
队列。 - 如果入队成功,任务会等待空闲线程执行。如果没有空闲线程,则创建一个非核心线程来处理任务。
- 如果
SynchronousQueue
已有任务等待,入队操作会阻塞。
适用场景:
- 当需要执行大量短时间的任务时,
CachedThreadPool
能够有效提高线程复用率,显著提高性能。 - 线程在60秒后回收,即使没有任务,也不会占用很多资源。
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
运行流程:
- 核心线程数与最大线程数相等,均为传入的
nThreads
。 - 仅创建核心线程,不能创建非核心线程。
- 如果核心线程空闲,任务直接交给核心线程执行;否则,任务会进入
LinkedBlockingQueue
等待执行。
与CachedThreadPool
的区别:
FixedThreadPool
只会创建核心线程,而CachedThreadPool
只会创建非核心线程。FixedThreadPool
的线程不会被回收,线程会阻塞在LinkedBlockingQueue.take()
,因此在没有任务时,FixedThreadPool
占用的资源更多。- 两者都几乎不会触发拒绝策略。
FixedThreadPool
因为阻塞队列很大(最大为Integer.MAX_VALUE
),而CachedThreadPool
因为线程池最大容量很大(最大为Integer.MAX_VALUE
)。
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
运行流程:
- 仅有一个核心线程,
corePoolSize
与maximumPoolSize
均为1。 - 使用
LinkedBlockingQueue
(容量很大),因此不会创建非核心线程。 - 所有任务按照先来先执行的顺序执行。如果唯一的线程不空闲,新任务会进入队列等待执行。
适用场景:
- 适用于需要串行执行任务的场景,保证任务按顺序执行。
newScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
ScheduledThreadPoolExecutor
的构造函数:
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
特点:
- 创建一个固定长度的线程池,支持定时和周期性任务执行。
corePoolSize
表示核心线程数,而最大线程数为Integer.MAX_VALUE
。- 使用
DelayedWorkQueue
来管理定时和延迟任务。
适用场景:
- 适用于需要定时或周期性执行任务的场景,如定期备份、定时清理任务等。
小结
ThreadPoolExecutor
通过管理核心线程和非核心线程的数量、维护阻塞队列中的任务、处理线程池的状态变化,从而高效地管理并发任务的执行,并实现线程的复用,避免频繁的线程创建和销毁。线程池的设计使得它能够灵活地控制并发,提供高效的资源管理。