前言
本文会分析到
ThreadPoolExecutor的线程池是如何工作的,包括基本属性,内部类Worker,核心方法execute,runWorker,addWorker等等.
例子1
用一个简单的例子看看线程池是如何操作的
package com.threadpool;
public class FixPoolDemo {
private static Runnable getThread(final int i) {
return new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
};
}
public static void main(String[] args) {
ExecutorService fixPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
fixPool.execute(getThread(i));
}
fixPool.shutdown();
}
}
输出: 提交
10个任务(Runnable)进入线程池进行处理,然后关闭线程池.
0
4
3
1
2
5
7
8
9
6
线程池的类结构
由下图可以知道
ThreadPoolExecutor是一个ExecutorService, 从上面的例子中可以看到Executors.newFixedThreadPool(5)返回一个ExecutorService,而这个返回的ExecutorService本质上是一个ThreadPoolExecutor.
![[Java源码][并发J.U.C]---解析线程池之ThreadPoolExecutor(2)_第1张图片](http://img.e-com-net.com/image/info10/e04ef6b39f5a484d9b59c8cc674c2ee3.jpg)
图片.png
源码
本文的源码会基于上面的例子进行一步步分析.
Executors
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
ThreadPoolExecutor
构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
可以看到构造方法中有几个参数,这几个参数很重要.
corePoolSize: 核心线程池允许的最多线程个数
maximumPoolSize: 整个线程池允许的最多线程个数
keepAliveTime: 线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间。默认情况下，该参数只在线程数大于corePoolSize时才有用
workQueue: 阻塞队列, 放任务的队列
threadFactory: 创建线程的工厂
handler: 处理那些被线程池排斥的任务
属性
ctl对象中保存的值前3位保存的是runState(线程池的状态),后29位保存的是workerCount(worker的数量).
/**
* ctl对象中保存的值前3位保存的是runState,后29位保存的是workerCount
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
线程池的各种状态值:
RUNNING: 接受新任务并且处理队列中的任务
SHUTDOWN: 不接受新任务,但是处理队列中的任务
STOP: 不接受新任务,不处理队列中的任务并且中断正在执行的任务
TIDYING: 属于到terminated的一个中间状态, 所有线程已经停止并且workerCount为0,线程池的状态会变成TIDYING并调用terminated()方法
TERMINATED:terminated()方法已经完成
/**
* 线程池的各种状态值
* RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
*/
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;
封装获得状态值
runState以及workerCount的方法
/**
* 分别计算runState, workerState, c
*/
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
/*
* Bit field accessors that don't require unpacking ctl.
* These depend on the bit layout and on workerCount being never negative.
*/
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
/**
* Attempts to CAS-increment the workerCount field of ctl.
*/
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
/**
* Attempts to CAS-decrement the workerCount field of ctl.
*/
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
/**
* Decrements the workerCount field of ctl. This is called only on
* abrupt termination of a thread (see processWorkerExit). Other
* decrements are performed within getTask.
*/
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
内部类Worker
Worker继承了
AQS也实现了Runnable,表明它既是一把锁,也是一个可以被执行的任务.
首先实现Runnable比较好理解,因为可以被当做任务来执行,而这个任务可以是一个不断从阻塞队列中获取新任务的一个任务(可以在runWorker方法中看到,后面会分析).
/**
* Worker即是一个互斥锁,不能重入,也是一个Runnable
* 锁状态值:
* -1: 初始化,线程thread未启动
* 0: 线程thread已启动, 但是该锁未被任何线程获得
* 1: 线程thread已启动, 并且该锁已被某个线程独占
*/
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
/** 当前worker运行的线程 */
final Thread thread;
/** 线程启动的时候执行的第一个任务 */
Runnable firstTask;
/** 执行的任务数量 */
volatile long completedTasks;
/** 构造方法 根据当前worker生成一个线程 锁的状态值设置为-1*/
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);
}
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(); }
/** 只有线程启动了的时候才去尝试中断线程 启动的标志就是锁状态值>=0*/
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
对于为什么需要继承
AQS,将自己包装成一个互斥锁不可重入锁. 主要是为了控制中断, 那就看一个该Runnable的run()方法, 可以看到该方法是调用外面的runWorker(Worker w)方法.
runWorker方法
可以看到该方法是不断从阻塞队列中获取任务进而来执行,但是在任务执行前后有上锁和解锁.
联系到上面的
Worker类就可以知道为什么需要继承AQS:
1. 因为Worker是互斥锁, 在运行中需要上锁,所以就不能中断,因为ThreadPoolExecutor的shutdown方法中断前需要先获得锁.
2. 因为Worker是不可重入的,所以interruptIdleWorkers()方法尝试中断该线程,需要先获得锁.
基于上面两点达到可以控制中断的目的并且不是为了并发.
final void runWorker(Worker w) {
// 获得当前线程 (执行该runWorker方法的线程)
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
/** 先解锁,将锁状态值设置为0,因此w的thread将允许被中断 */
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
// 上锁,为了shutdown()时不可以中断正在运行的worker
w.lock();
/**
* 如果线程池正在stop,保证当前线程中断状态是中断的
* 如果不是,保证当前线程中断状态不是中断的
* 为什么呢?因为stop状态的时候需要去中断任务,所以需要设置中断状态
*/
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt(); //中断
try {
beforeExecute(wt, task); //子类实现
Throwable thrown = null;
try {
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 {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
/**
* 1. completedAbruptly为false, 说明task为null或者getTask()为null
* 2. completedAbruptly为true, 说明task.run()执行出现异常
*/
processWorkerExit(w, completedAbruptly);
}
}
getTask()
作用: 被
runWorker方法调用,用于从阻塞队列中获得任务供线程池中的线程来执行. 在某些情况下会返回null,代码注释中有详细分析.
private Runnable getTask() {
/** 表示最后一次poll()方法是否超时 从而来决定是否要退出(看下面的分析) */
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.
/**
* 以下两种情况下减少一个线程并且返回null
* 1. rs >= SHUTDOWN && rs >= STOP -> rs >= STOP
* 2. rs >= SHUTDOWN && rs < STOP && workQueue.isEmpty() == true
* -> rs == SHUTDOWN && workQueue.isEmpty() == true
*
* 1. 因为线程池已经至少处于STOP状态,表明不接受新任务,所以返回null即可
* 2. rs == SHUTDOWN表示线程池不接受新任务但是处理队列中的任务
* 如果队列为空,直接返回null即可
*/
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
/** 允许核心线程有等待时间或者wc > corePoolSize
* wc > corePoolSize表明核心线程以外的线程默认是有等待时间的
* 等待一段时间后如果还没有接受到新任务后将被清除 */
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
/**
* 进入到这里有几种可能性
* 1. wc > maximumPoolSize 或者 wc > corePoolSize 核心线程以外的线程肯定要进入到这里
* 2. allowCoreThreadTimeOut == true && wc <= 1 && workQueue.isEmpty() == true
*
* 尝试消除该线程(因为返回null,该线程的runWorker将退出while循环,进而退出run方法)
* 失败则继续for循环尝试(continue)
*/
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
execute(Runnable command)
这是核心方法,
command为提交请求被执行的任务.
作用: 提交command至线程池等待执行. 如果因为线程池关闭或者饱和不能被执行, 会拒绝任务并且通过RejectedExecutionHandler来处理该command.
整个过程总共分为以下三步:
1. 如果线程个数小于核心线程池的个数,尝试启动一个新的线程去执行command,command作为这个线程的第一个任务.
2. 如果这个这个任务可以成功入队列,我们也需要双重验证一下我们是否应该添加一个线程, (因为存在的线程在上次检查后没有了) 或者进入这个方法后线程池关闭了,因此我们需要双重检查状态 如果线程池停止了我们需要从队列中回滚 如果线程池中没有线程了新开启一个线程.
3. 如果无法将任务入队列,我们需要添加一个新的线程,如果失败则表明线程池shutdown或者饱和了,所以拒绝任务.
/**
* 在未来的某个时间执行指定的任务.
* 这个任务可能在一个新的线程执行也有可能在一个已经存在的线程池中的线程执行
*
* 如果这个任务提交请求后不能被执行,无论是因为线程池已经被关闭或者因为线程池的容量已经达到最大,
* 这个任务会被当前的RejectedExecutionHandler来处理
*
* @param command the task to execute
* @throws RejectedExecutionException at discretion of
* {@code RejectedExecutionHandler}, if the task
* cannot be accepted for execution
* @throws NullPointerException if {@code command} is null
*/
public void execute(Runnable command) {
// 如果任务为null, 返回空指针异常
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 如果线程个数小于核心线程池的个数,尝试启动一个新的线程去执行command,command作为这个线程的第一个任务
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 如果这个这个任务可以成功入队列,我们也需要双重验证一下我们是否应该添加一个线程
* (因为存在的线程在上次检查后没有了) 或者进入这个方法后线程池关闭了
* 因此我们需要双重检查状态 如果线程池停止了我们需要从队列中回滚 如果线程池中没有线程了新开启一个线程
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
* 如果无法将任务入队列,我们需要添加一个新的线程,如果失败则表明线程池shutdown或者饱和了
* 所以拒绝任务
*/
int c = ctl.get();
/** 如果workerCount个数小于核心线程数量 */
if (workerCountOf(c) < corePoolSize) {
/** 如果加入到核心线程池中成功就会直接返回 */
if (addWorker(command, true))
return;
/**
* 加入到核心线程池失败
* 1. 由于并发问题,别的线程在执行addWorker先使得核心线程池变满
* 2. 线程池shutdown, 所以没办法加入到线程池中
*/
c = ctl.get();
}
/** 执行到这里表明workerCount个数大于等于corePoolSize */
/** 如果线程池属于运行状态并且command成功加入到阻塞队列中 */
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
/** 如果线程池现在不属于运行状态并且成功从阻塞队列中删除command
* 则执行reject方法处理该command*/
if (! isRunning(recheck) && remove(command))
reject(command);
/** 执行到这里表明有这两种可能性
* 1. 线程池处于运行状态
* 2. 线程池不处于运行状态并且从阻塞队列中删除command失败
* 基于上面两种可能性,如果此时workerCount为0,则通过addWorker方法增加一个Worker
*/
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
/** 执行到这里表明线程池不是运行状态或者workerQueue中加入command失败*/
/** 尝试加入到核心线程池以外 如果失败则调用reject方法处理该command */
else if (!addWorker(command, false))
reject(command);
}
addWorker(Runnable firstTask, boolean core)
firstTask:Worker中的线程启动时执行的第一个任务.
core:true表示核心线程的corePoolSize为临界点,false表示maximumPoolSize为临界点.
返回值:true表示成功
作用: 检查一个worker是否被添加到当前的线程池(拥有指定的临界点),如果成功,workerCount会被调整(加1), 如果可能,这个新创建的worker,会被启动并且执行firstTask作为它的第一个任务.
/**
* Checks if a new worker can be added with respect to current
* pool state and the given bound (either core or maximum). If so,
* the worker count is adjusted accordingly, and, if possible, a
* new worker is created and started, running firstTask as its
* first task.
*
* 检查一个新的worker是否被添加到当前的线程池(拥有指定的临界点)
* 如果成功,workerCount会被调整(加1), 如果可能,这个新创建的worker
* 会被启动并且执行firstTask作为它的第一个任务
*
* This method returns false if the pool is stopped or
* eligible to shut down. It also returns false if the thread
* factory fails to create a thread when asked. If the thread
* creation fails, either due to the thread factory returning
* null, or due to an exception (typically OutOfMemoryError in
* Thread.start()), we roll back cleanly.
*
* 这个方法返回false 如果线程池已经停止或者有资格关闭(不太明白这句话)
* 同样也会返回false 如果创建线程失败无论因为thread factory返回null
* 或者因为异常情况(通常是线程启动时抛出OutOfMemoryError异常)
* 我们都会进行回滚
*
* @param firstTask Worker中的线程启动时第一个执行的任务(如果不为null)
* @param core true 表明用核心线程池当作临界点
* false把maximumPoolSize当作临界点
* @return true if successful
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/**
* rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null || workQueue.isEmpty())
*
* 会出现以下三种可能性
* 1. rs >= SHUTDOWN && rs != SHUTDOWN --> rs > SHUTDOWN
* -> 表明rs > SHUTDOWN,线程池已经不接受新任务.
* 2. rs == SHUTDOWN && firstTask != null
* -> 表明线程池处于关闭状态,不接受新任务.
* 3. rs == SHUTDOWN && firstTask == null && workQueue.isEmpty() == true
* -> 如果线程池处于shutdown状态并且firstTask为null并且阻塞队列为空 则不接受线程
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
/** 内层循环 负责将worker数量+1 */
for (;;) {
int wc = workerCountOf(c);
/** 检查是否超过容量 */
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
/** 尝试增加workerCount */
if (compareAndIncrementWorkerCount(c))
break retry;
/** 如果CAS操作失败 则重新获取c检查是否有被修改过 */
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/**
* 在状态值已经改变的情况下 (workerCount+1)
* 需要实际去执行启动线程做任务
*/
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
/** 利用firstTask初始化一个worker */
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
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());
/**
* 两种情况下 会尝试启动线程
* 1. rs < SHUTDOWN
* -> 线程池在running的情况下启动线程去执行任务
* 2. rs == SHUTDOWN && firstTask == null
* -> 对应到execute方法中第二步的addWorker(null, false)
*/
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();
/** largestPoolSize 记录着线程池生命周期内拥有最多线程的个数 */
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start(); /** 开启线程执行的t.run方法继而执行runWorker方法*/
workerStarted = true; // 标记workerStarted状态值
}
}
} finally {
/** 如果线程没有启动则执行addWorkerFailed方法 */
/** rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null)
*
* 以下两种情况下workerStarted为false
* 1. rs >= SHUTDOWN && rs != SHUTDOWN -> rs > SHUTDOWN
* 2. rs >= SHUTDOWN && firstTask != null
*/
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
可以看到该方法在检查一系列线程池的状态后将
workerCount加1,然后启动worker中的线程去执行任务, 也就是去执行上面提到的runWorker方法. 进而可以看到线程池就已经在工作了.
有几种情况下线程并没有启动,此时会调用
addWorkerFailed,这个方法会放到下篇文章进行分析.
参考
1.
java 1.8源码