前言
众所周知,JDK为我们提供了一系列线程池类,ThreadPoolExecutor
就是一个很典型的实现,以下对JDK的线程池机制分析都将围绕这一个类来描述。
开始
要使用ThreadPoolExecutor
,我通常会这样做:
//创建一个核心线程数为4的线程池
ExecutorService es = Executors.newFixedThreadPool(4);
Task t = new Task();
for (int i = 0; i < 100; i++) {
es.submit(t);
}
es.shutdown();
但是这里面发生了什么事,它的代码实现又是怎么一回事呢,我们来一探究竟。
细究
通过对submit
方法打断点,我们可以发现,在AbstractExecutorService
这个类里边半实现了submit
方法
//AbstractExecutorService#submit
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);//mark here
return ftask;
}
为什么我说是“半实现”呢,因为在我mark的那行代码的execute(Runnable)
方法仍然是一个抽象方法,在ThreadPoolExecutor类中,提供了对它的具体实现。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//拿到当前的work(或者说是Runnable)数量
int c = ctl.get();
//如果工作的线程小于核心线程数的话
if (workerCountOf(c) < corePoolSize) {
//addWorker()方法里面会创建Worker类和对应的线程。
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果大于核心线程数,就把这个Runnable对象command加入阻塞队列中,
//同时应该二次检查是否应该创建新的线程,
//如果线程池shutdown,就执行reject操作,就是拒绝服务了。
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);
}
//如果无法加入阻塞队列,直接拒绝服务
else if (!addWorker(command, false))
reject(command);
}
再来看一下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 ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//用CAS操作成功增加worker数量之后,跳出大循环
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
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//开始创建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());
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;
//执行到这里,Worker就算是创建成功了
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//成功创建Worker之后,启动线程。
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
那这个Worker类到底是一个怎么样的数据结构呢,再来看一下。
当我们创建一个Worker的时候,就把我们通过submit方法传递进来的Runnable给了firstTask
属性,然后再通过工厂方法创建一个线程。同时Worker又是一个Runnable对象,在重写的run()方法中,调用了外部的runWorker(Worker)
方法。
正如上文所讲的一样,创建了线程就会start(),每个线程所做的就是这里的run方法,再细化,就是runWorker(Worker)
方法
首先,把传递进来的Worker的Runnable对象给task,这时候的task局部对象有两种的取值,一种是我们直接submit进来的Runnable对象,另一种是null,出现null的情况是:当前线程的数量大于等于核心线程数量。
所以,在while循环的时候,我们才会用task != null || (task = getTask() != null)
这种表示,getTask
方法待会再看,它会在阻塞队列中获取Runnable对象。
拿到了task,就可以调用run方法了,因为我们现在就是在工作的线程里面。
最后,来看看getTask()
方法。
getTask方法的外部包着一个死循环for(;;),这是因为poll方法在阻塞队列空的时候并不会把当前线程阻塞住,它还会往下走。
但是如果boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
这条语句不成立,timed为false,就可以成功的将线程阻塞住,我找遍了ThreadPoolExecutor这个类,都没有找到allowCoreThreadTimeOut
这个属性的赋值的地方,那么就默认成立false,所以,在阻塞队列拿Runnable对象就主要是take()方法了。
结尾
正是这样不停向阻塞队列拿Runnable或者创建规定数量的线程执行Runnable的机制,保证了线程池的正常运行,当然我今天记录下来的只是冰山一角,这里面还是有很多地方值得我们去研究,比如AQS类,CAS机制等等。才疏学浅,只敢写下这些了。