目录
1 前言
本人使用的jdk版本为8。
本文介绍ThreadPoolExecutor具体的几种实现形式,ThreadPoolExecutor的底层原理和使用参见:Java中的线程池(ThreadPoolExecutor实现原理和使用)。
Executor
框架最核心的类是ThreadPoolExecutor
,它是线程池的实现类,主要由下列4个组件构成。
corePool
:核心线程池的大小。maximumPool
:最大线程池的大小。BlockingQueue
:用来暂时保存任务的工作队列。RejectedExecutionHandler
:当ThreadPoolExecutor
已经关闭或ThreadPoolExecutor
已经饱和时(达到了最大线程池大小且工作队列已满),execute()
方法将要调用的Handler
。
通过Executor
框架的工具类Executors
,可以创建3种类型的ThreadPoolExecutor
。
FixedThreadPool
SingleThreadExecutor
CachedThreadPool
2 FixedThreadPool详解
FixedThreadPool
被称为可重用固定线程数的线程池。下面是FixedThreadPool
的源代码实现。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
FixedThreadPool
的corePoolSize
和maximumPoolSize
都被设置为创建FixedThreadPool
时指定的参数nThreads,意味着线程池不能扩充
。
当线程池中的线程数大于corePoolSize
时,keepAliveTime
为多余的空闲线程等待新任务的最长时间,超过这个时间后多余的线程将被终止。这里把keepAliveTime
设置为0L
,意味着多余的空闲线程会被立即终止,线程池的线程数量不会超过corePoolSize。
FixedThreadPool
的execute()
方法的运行示意图如下图所示。
图中1
:如果当前运行的线程数少于corePoolSize
,则创建新线程来执行任务。图中2
:在线程池完成预热之后(当前运行的线程数等于corePoolSize
),将任务加入LinkedBlockingQueue
。图中3
:线程执行完1
中的任务后,会在循环中反复从LinkedBlockingQueue
获取任务来执行。
FixedThreadPool
使用无界队列LinkedBlockingQueue
作为线程池的工作队列(队列的容量为Integer.MAX_VALUE
)。
使用无界队列作为工作队列会对线程池带来如下影响:
- 当线程池中的线程数达到
corePoolSize
后,新任务将在无界队列中等待,因此线程池中的线程数不会超过corePoolSize
。 - 由于上一点,使用无界队列时
maximumPoolSize
将是一个无效参数。 - 由于前面两点,使用无界队列时
keepAliveTime
将是一个无效参数。 - 由于使用无界队列,运行中的
FixedThreadPool
(未执行方法shutdown()
或shutdownNow()
)不会拒绝任务(不会调用RejectedExecutionHandler.rejectedExecution
方法)。
3 SingleThreadExecutor详解
SingleThreadExecutor
是使用单个worker
线程的Executor
。下面是SingleThreadExecutor
的源代码实现:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService(
new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
);
}
SingleThreadExecutor
的corePoolSize
和maximumPoolSize
被设置为1。其他参数与FixedThreadPool
相同。SingleThreadExecutor
使用无界队列LinkedBlockingQueue
作为线程池的工作队列(队列的容量为Integer.MAX_VALUE
)。SingleThreadExecutor
使用无界队列作为工作队列对线程池带来的影响与FixedThreadPool
相同,这里就不赘述了。
SingleThreadExecutor
的运行示意图如下图所示:
上图1:
如果当前运行的线程数少于corePoolSize
(即线程池中无运行的线程),则创建一个新线程来执行任务。上图2:
在线程池完成预热之后(当前线程池中有一个运行的线程),将任务加入LinkedBlockingQueue
。上图3:
线程执行完上图1
中的任务后,会在一个无限循环中反复从LinkedBlockingQueue
获取任务来执行。
4 CachedThreadPool详解
CachedThreadPool
是一个会根据需要创建新线程的线程池。下面是创建CachedThreadPool
的源代码。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
CachedThreadPool
的corePoolSize
被设置为0,即corePool
为空;maximumPoolSize
被设置为Integer.MAX_VALUE
,即maximumPool
是无界的。这里把keepAliveTime
设置为60L
,意味着CachedThreadPool
中的空闲线程等待新任务的最长时间为60秒
,空闲线程超过60秒
后将会被终止。
FixedThreadPool
和SingleThreadExecutor
使用无界队列LinkedBlockingQueue
作为线程池的工作队列。CachedThreadPool
使用没有容量的SynchronousQueue
作为线程池的工作队列,但CachedThreadPool
的maximumPool
是无界的。这意味着,如果主线程提交任务的速度高于maximumPool
中线程处理任务的速度时,CachedThreadPool
会不断创建新线程。极端情况下,CachedThreadPool
会因为创建过多线程而耗尽CPU和内存资源。
CachedThreadPool
的execute()
方法的执行示意图如下图所示:
上图1:
首先执行SynchronousQueue.offer(Runnable task)
。如果当前maximumPool
中有空闲线程正在执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)
,那么主线程执行offer
操作与空闲线程执行的poll
操作配对成功,主线程把任务交给空闲线程执行,execute()
方法执行完成;否则执行下面的步骤2
。上图2:
当初始maximumPool
为空,或者maximumPool
中当前没有空闲线程时,将没有线程执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)
。这种情况下,步骤1会失败。此时CachedThreadPool
会创建一个新线程执行任务,execute()
方法执行完成。上图3:
.在步骤2
中新创建的线程将任务执行完后,会执行SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)
。这个poll
操作会让空闲线程最多在SynchronousQueue
中等待60秒
钟。如果60秒
钟内主线程提交了一个新任务(主线程执行步骤1
),那么这个空闲线程将执行主线程提交的新任务;否则,这个空闲线程将终止。由于空闲60秒
的空闲线程会被终止,因此长时间保持空闲的CachedThreadPool
不会使用任何资源。
注:不管怎样,SynchronousQueue都不会存放数据,因为如果若没有线程在向队列中要任务,offer()会执行失败,线程池会直接创建一个worker去执行这个任务;若有线程向队列中要任务,则offer()到队列的任务会立刻被线程执行,不会放在队列中。
前面提到过,SynchronousQueue
是一个没有容量的阻塞队列。每个插入操作必须等待另一个线程的对应移除操作,反之亦然。CachedThreadPool
使用SynchronousQueue
,把主线程提交的任务传递给空闲线程执行。
若没有空闲线程,则offer会返回false,则直接创建一个新的worker去执行任务,绕过了队列。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 若没有空闲线程,则offer会返回false
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 直接创建一个新的worker去执行任务,绕过了队列
else if (!addWorker(command, false))
reject(command);
}