在平常的开发中,线程池是经常有所接触的。当没有使用线程池的时候,执行异步任务就需要使用new创建一个线程来执行任务,在任务完成后线程便直接销毁了,这样的操作是有很大的开销的。而线程池为了解决在大量执行异步任务时,能够提供较好的性能,因为线程池中的线程是可以复用的。且线程池可以控制和管理资源,譬如限制线程的个数、动态新增线程等。
Java中的ThreadPoolExecutor中有提供可调参数和可扩展的接口,以此来满足不同场景下的需求,开发人员可以方便的使用Executors中的工厂方法,如:newCachedThreadPool(线程个数最多可达Integer.MAX_VALUE,线程自动回收)、newFixedThreadPool(固定大小的线程池)、newSingleThreadExecutor(单线程线程池),另外,开发人员还能进行自定义。
常见的几种创建线程池的方法
首先来看下ThreadPoolExecutor的类图,如下:
从上面的类图中可以看到Executor是顶层接口,在它里面只有一个execute()方法,ExecutorService继承自Executor,且也是一个接口,在这个接口中定义了关闭的功能,且定义了两种方式:shutDown和shutDownNow,shutdown 方法将允许先前提交的任务进行终止,而 shutdownNow 方法可以阻止等待的任务启动并尝试停止当前正在执行的任务。对于AbstractExecutorService这个抽象类,主要是实现了ExecutorService接口中的定义的一些执行方法。
ThreadPoolExecutor则是继承了AbstractExecutorService,在ThreadPoolExecutor类中有一个ctl原子变量,其主要作用是用于记录线程池状态和线程池中的线程个数。接下来,我们来简单看下ThreadPoolExecutor中定义的一些属性,代码如下:
// 高3位用来便是线程池状态,低29位用来表示线程的个数
// 默认是running状态,线程个数为0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 线程个数掩码位数,并不是所有平台的int类型都是32位的,准确的说是在具体平台下的二进制位数-3后的剩余位数所表示的数才是线程个数
private static final int COUNT_BITS = Integer.SIZE - 3;
// 线程最大个数(低29位)
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 以下是线程池状态
// 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;
// 所有任务执行完(包含队列里的任务)后,当前线程池活动线程数为0,将要调用terminated方法
private static final int TIDYING = 2 << COUNT_BITS;
// 终止状态,terminated方法调用完成以后的状态
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
// 获取高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 wc) { return rs | wc; }
关于线程池状态的转换如下:
- RUNNING->SHUTDOWN:显示低啊用shutdown方法,或者隐式调用用finalize()方法里的shutdown()方法。
- RUNNING或SHUTDOWN->STOP:显式调用shutdownNow()方法。
- SHUTDOWN->TIDYING:当线程池和任务队列都为空时。
- STOP->TIDYING:当线程池为空时。
- TIDING->TERMINATED:当terminated()hook方法执行完成时。
前面开始的时候提到了newCachedThreadPool(线程个数最多可达Integer.MAX_VALUE,线程自动回收)、newFixedThreadPool(固定大小的线程池)、newSingleThreadExecutor(单线程线程池)这几个方法,在说这几个方法之前需要先解释一下在ThreadPoolExecutor中几个相关的属性,如下:
- corePoolSize:线程池核心线程个数。
- maximumPoolSize:线程池最大线程数。
- keepAliveTime:存活时间,如果当前线程池中的线程数量比核心线程数量多,并且是闲置状态,则这些闲置的线程能存活的最大时间。
- TimeUnit:存活时间的时间单位
- workQueue:用于保存等待执行的任务阻塞队列,比如基于数组的有界队列ArrayBlockingQueue、基于链表的无界LinkedBlockingQueue、最多只有一个元素的SynchronousQueue,以及优先级队列PriorityBlockingQueue等。
- ThreadFactory:创建线程池的工厂。
- RejectedExecutionHandler:饱和策略,当队列满并且线程个数达到maximunPoolSize后所采取的的策略,比如AbortPolicy(抛出异常)、CallerRunsPolicy(使用调用者所在线程来运行任务)、DiscardOldestPolicy(调用poll丢弃一个任务,执行当前任务),DiscardPolicy(默默丢弃,不抛异常)。
这个方法的作用是用于创建一个按需创建线程的线程池,初识线程池为0,最多线程个数为Integer.MAX_VALUE,阻塞队列为SynchronousQueue。keepAliveTime=60表示当前线程在60s内空闲则回收,这个方法的特殊之处在于加入同步队列后会立马执行任务,因为队列中最多只允许有一个任务。代码如下:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
newFixedThreadPool
这里用于创建一个核心线程个数和最大线程个数都为nThreads的线程池,且阻塞队列长度为Integer.MAX_VALUE。keepAliveTime=0说明了线程个数比核心线程个数多并且当前空闲则回收。代码如下:
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}
newSingleThreadExecutor
创建一个核心线程个数和最大线程个数都为1的线程池,且阻塞队列的长队为Integer.MAX_VALUE,keepAliveTime=0说明了线程个数比核心线程个数多并且当前空闲则回收。代码如下:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
在上面的类图中的Worker,这个类继承了AQS和Runnable接口,它是具体承载任务的对象,Worker不仅继承了AQS,还自己简单的实现了不可重入锁,其中的state为0时,则表示锁未被获取,state=1时表示锁已经被获取,state=-1时时创建Worker时的默认状态,创建时设置state为-1是为了避免该线程在运行runWorker()方法前被中断。代码如下:
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
// 正在运行woker线程
final Thread thread;
// 传入的任务
Runnable firstTask;
// 完成的任务数 监控用
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
execute方法
ThreadPoolExecutor#execute方法的作用是吧任务提交到线程池中进行执行,客户端提交任务到线程池的流程图答题如下:
从上图的运行中,可以看出ThreadPoolExecutor的实现实际上是一个生产消费者模式,当客户端添加任务到线程池时相当于生产者生产元素,workers线程工作集中的线程直接执行任务或者从任务队列里获取任务时,则相当于消费者消费元素。execute方法的具体代码如下:
public void execute(Runnable command) {
// (1)如果任务为null,抛空指针异常
if (command == null)
throw new NullPointerException();
// (2)获取当前线程池的状态和线程个数变量的组合值
int c = ctl.get();
// (3)当前线程池中的数量是否小于核心线程池,小于则开启新线程运行
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// (4)如果线程池处于RUNING状态,则添加任务到阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
//(4.1)二次检查
int recheck = ctl.get();
// (4.2)如果当前线程池状态不是RUNNING,则从任务队列中删除任务,并执行拒绝策略。
if (! isRunning(recheck) && remove(command))
reject(command);
// (4.3)否则如果当前线程池为空,则添加一个线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//(5)如果队列已满,则新增线程,新增失败则执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
上面代码中主要步骤可分三步,但是这里我们对其进行了一下细分,(1)、(2)两步为非主要步骤,这里就不赘述了,第(3)步代码判断当前线程池中的线程个数如果小于corePoolSize,便会向workes中新增一个核心线程来执行任务。
如果当前当前线程池中的线程数大于等于corePoolSize,则执行第(4)步,在这里首先会判断当前线程池的状态是否为RUNNING,是则添加当前任务到队列中。这里判断线程池的状态,是因为有可能线程池已经处于非RUNNING状态了,而非RUNNING状态下是要抛弃新任务的。
当向队列中添加任务成功,还需要对其进行二次检查,便执行(4.2)代码,这里进行二次检查的原因,是因为在添加任务到队里中后,执行(4.2)前线程池的状态可能已经发生了变化。如果当前线程池状态不是RUNNING状态,便把任务从队列中移除,移除后在执行拒绝策略。如果通过路二次校验,便会执行(4.3)来重新判断当前线程池里面是否还有线程,没有的话则添加一个空任务到队列中。
如果(4)执行不通过的话,则说明任务队列已满,便会执行(5)来添加一个任务,如果当前线程池线程个数大于maximumPoolSize,便会添加失败,然后执行拒绝策略。
在分析完ThreadPoolExecutor#execute方法后,我们还需要对其方法中的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.
// (1) 检查队列是非只在必要时为空,如果判断线程状态是否为非运行状态,并且为非SHUTDOWN状态、firstTask为空、队列非空,就不能新增线程
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
// (2) CAS循环增加线程个数
for (;;) {
// 计算线程个数
int wc = workerCountOf(c);
// (2.1)如果线程个数超限,则返回false。
// 如果当前线程大于等于最大线程数、等于核心线程数,非核心线程大于线程池数,说明已经到了阈值,表示不能再新增线程路。
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// (2.2)CAS新增线程个数,同时只有一个线程活动。
// ctl+1 工作线程池数量+1, 如果成功,就跳出死循环。cas操作如果为true,表示新增成功,然后退出。
if (compareAndIncrementWorkerCount(c))
break retry;
// (2.3)CAS失败路,则看线程池状态是否变化了,变化则跳出外层循环,重新尝试获取线程池状态,否则内层循环,重新执行CAS。
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// (3)到此便说明前面执行全部通过
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// (3.1)创建worker
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
// (3.2) 加独占锁,为了实现workers同步,因为可能多个线程调用了线程池的execute方法
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// (3.3)重新检查线程池状态,以避免在获取锁之前,调用了shutdown方法
int rs = runStateOf(ctl.get());
// rs小于 SHUTDOWN,就是表示此时是 RUNNING 状态,rs等于 SHUTDOWN 和firstTask 为空,表示是从队列中处理任务,那就可以放到集合中
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// 线程还没start,就是alive,直接抛异常。
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// (3.4)添加任务
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
// 记录最大线程数
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// (3.5)添加成功后启动任务
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// (3.6)//失败回退,从wokers移除w,线程数减1,尝试结束线程池。
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
这段代码比较长,但主要可分为两部分,第一部分是通过双重循环CAS操作增加线程数,第二部分是并发安全的任务添加到workers里面,并启动任务。这里首先看第(1)步代码的判断逻辑:
rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty())
这段代码可以等价于:
rs >= SHUTDOWN &&
(rs != SHUTDOWN || I
firstTask != null || II
workQueue.isEmpty()) III
- I 表示当前线程池状态为STOP、TIDYING或TERMINATED。
- II 表示当前线程池状态为SHUTDOWN,并且已经有了第一个任务。
- III 表示当前线程池状态为SHUTDOWN,并且任务队列已空。
内存循环的作用是使用CAS操作增加线程数,代码(2.1)判断如果线程个数超限则返回false,否则执行(2.2)CAS,来操作设置线程个数。CAS成功则退出双循环,CAS失败则执行(2.3),看当前线程池的状态是否发生了变化,如果变了,贼再次进入外层循环重新获取线程池状态,否则进入内循环继续进行CAS尝试。
执行带(3)时,则表示前面的CAS成功增加路线程个数,但是现在任务还没开始执行。这里使用全局独占锁来控制把新增的Worked添加到workers中。在(3.1)处创建了一个工作线程Worker,(3.2)处获取路独占锁,(3.3)处重新检查了线程池状态,这里检查的目的是为了避免在获取锁之前,其他的线程执行shutdown方法关闭了线程池。如果线程池已经关闭了,则释放锁,新增线程失败,否则执行(3.4)添加工作线程到workers中去然后释放锁,最后(3.5)判断如果新增工作线程成功,则启动工作线程。
工作线程Worker的执行
当任务提交到线程池后,便由Worker来执行,这里先看下Worker的构造函数,代码如下:
Worker(Runnable firstTask) {
setState(-1); // 在调用runworker之前,禁止中断
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this); // 创建一个线程
}
在构造函数中首先设置Worker的状态为-1,这里为了避免当前的Worker在调用runWorker方法前被中断(当其他线程调用了线程池的shutdownNow时,如果Worker的状态大于等于0时,则会中断该线程)。这里设置了线程状态为1,所以线程不会被中断,在执行runWorker的时候才会把state设置为0,在这个时候调用shutdownNow的便可以中断线程。代码如下:
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// (1)将state设置为0,允许中断
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// (2)task不为空 或者阻塞队列中拿到了任务
while (task != null || (task = getTask()) != null) {
// (2.1)获取独占锁
w.lock();
// 如果当前线程池状态等于stop 就中断
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// (2.2)执行前做一些准备
beforeExecute(wt, task);
Throwable thrown = null;
try {
// (2.3)执行任务
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.4)执行完任务做一些事情
afterExecute(task, thrown);
}
} finally {
task = null;
// (2.5)统计当前worker完成了多少任务
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// (3)执行清理工作
processWorkerExit(w, completedAbruptly);
}
}
上面的代码中,首先会在(1)处将state设置为0,表示线程可以中断。当执行到(2)处的时候,如果当前task==null或者getTask从任务队列获取的时候返回null,便跳到(3)处执行。如果task不等于null,则执行(2.1)去获取工作线程内部持有的独占锁,然后再执行扩展接口代码(2.2),再具体任务执行前做些事情。当执行到(3.3)的时候,便是执行具体任务,代码(3.4)处表示在任务执行完之后再做点事情,(2.5)表示统计当前worker完成了多少任务,并释放锁。这段代码中在具体任务期间枷锁,是为了避免在任务运行期间,其他线程调用路shutdown后,这样正在执行的任务便会被中断(shutdown只会中断当前被阻塞挂起的线程)。(3)处代码如下:
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
// (3.1)统计整个线程池完成的任务个数,并从工作集中删除当前Worker
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
// (3.2)尝试设置线程池状态为TERMINATED,如果当前是SHUTDOWN状态并且工作队列为空,或者当前是STOP状态,当前线程池里没有活动线程。
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
上面的代码中,(3.1)处代码统计线程池完成任务个数,并且在统计前加了全局锁,把在当前工作线程中完成的任务累加到全局计数器中,然后从工作集中删除当前Worker,代码(3.2)处判断如前线程池状态如果是SHUTDOWN并且工作队列为空,或当前线程池状态是STOP,并且当前线程池里面没有活动的线程,则设置线程池状态为TERMINATED。如果设置为TERMINATED状态,则需要调用条件变量termination的singAll()方法激活所有因为调用线程池的awaitTermination方法被阻塞的线程。代码(3.3)处判断当前线程池里面的线程个数是否小于核心线程数,如果是则新增一个线程。
shutdown和shutdownNow操作
ThreadPoolExecutor#shutdown
在调用shutdown方法后,线程池就不能接受新的人物路,但是工作队列里面的任务还是要执行的。该方法会立刻返回并不会等待任务队列完成再返回。代码如下:
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//(1)权限检查
checkShutdownAccess();
// (2)设置当前线程池 状态为SHUTDOWN,如果已经是SHUTDOWN,则直接返回
advanceRunState(SHUTDOWN);
// (3)设置中断标志位
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// (4)尝试将状态设置为TERMINATED
tryTerminate();
}
上面代码在(1)处会进行权限检查,查看是否设置了安全管理器,是则看当前调用shutdown命令的线程时候有关闭线程的权限,如果有权限还要看调用线程是否有中断工作线程的权限,如果没有则抛出SecurityException或者NullPointerException。代码(2)处是表示如果当前线程池状态大于等于SHUTDOWN则直接返回,否则设置为SHUTDOWN状态,代码如下:
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
(3)处代码如下,这里设置所有空闲的线程为中断标志,首先加了把全局锁,同时只有一个线程可以调用shutdown方法设置中断标志,然后尝试获取Worker自己的锁,获取成功则设置中断标志。由于正在执行的任务已经获取到锁,所以正在执行的任务没有被中断。这里中断的是阻塞到getTask方法并企图从队列里面获取到任务的线程,也就是空闲线程。
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
// 如果工作线程没有被中断,并且没有正在运行则设置中断标志
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
(4)处代码如下,这段代码中首先使用CAS设置当前线程的状态为TIDYING,如果设置成功则执行扩展接口terminated在线程池状态变为TERMINATED之前做些事情,然后设置当前线程池的状态为TERMINATED。最后调用termination.signalAll()激活因调用条件变量termination的await系列方法而被阻塞的所有线程。
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 设置当前状态为TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
// 设置当前状态为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
// 激活因调用条件变量termination的await系列方法而被阻塞的所有线程
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
ThreadPoolExecutor#shutdownNow
调用ThreadPoolExecutor#shutdownNow方法后,该线程池就不会接受新的任务,并且丢弃工作队列里面的任务,正在执行的任务不会被中断,该方法会立刻返回,并不等待激活的任务执行完成。返回值为这时候队列里面被丢弃的任务列表。代码如下:
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//(1)权限检查
checkShutdownAccess();
//(2)设置当前线程池状态为STOP
advanceRunState(STOP);
// (3)中断所有线程
interruptWorkers();
// 将任务队列任务移到tasks中
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
上面代码中首先进行权限检查,然后设置当前线程状态为STOP,最后中断所有线程,这里需要注意的是,中断的所有线程包含空闲线程和正在执行任务的线程。最后把当前任务移到tasks列表中去。