线程池状态含义
RUNNING 接受新任务并且处理阻塞队列里的任务
SHUTDOWN :拒绝新任务但是处理阻 队列里的任务
STOP :拒绝新任务并且 抛弃阻塞队列 的任务 ,同时会中断正在处理的任务。
TIDYING 所有任务都执行完(包含阻 队列里面的任务)后当前线程池活动线程数为0 将要调用 terminated 方法
TERMINATED 终止状态, terminated 方法调用完成 以后的状态
线程池状态转换
RUNNING -> SHUTDOWN:由接收新任务变为拒绝新的任务,但是还是会处理阻塞队列里的任务 显式调用 shutdown方法 或者隐式调用了 finalize方法里面的 shutdown方法
RUNNING或 SHUTDOWN -> STOP :拒绝新任务并且抛弃阻塞队列并且终止正在执行的任务。显式调用 shutdownNow() 方法
SHUTDOWN->TIDYING 当线程池和任务队列都为空时;
STOP -> TIDYING 当线程池为空时
TIDY G -> TERM ATED terminated() hook 方法执行完成
线程池参数
corePoolSize :线程池 核心线程数
workQueue :用于保存等待执行的任务的阻塞队列,比如基于数组的有界
ArrayBlockingQueue 、基于链表的无界 LinkedBlockingQueu 、最多只有1个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue等。
maximunPoolSize 线程池最大线程数量。
ThreadFactory :创建线程的工厂
RejectedExecutionHandler :饱和策略队列满并且线程个数达到 maximunPoolSize后采取 策略,
比如 AbortPolicy (抛出异常)
CallerRunsPolicy (使用调用者所在线程来运行务);
DiscardOldestPolicy (调用 poll 丢弃1个任务,执行当前任务)
DiscardPolicy (默默丢弃,不抛出异常)
keeyAliveTime :存活时间 如果当前线程池中的线程数量比核心线程数 ,并闲置状态, 则这些闲置的线程能存活的最大时间
TimeUnit: 存活时间的时间单位
线程池提交任务的 execute 方法
public void execute(Runnable command) {
//任务为空直接抛出异常
if (command == null)
throw new NullPointerException();
//获取线程池状态和线程数
int c = ctl.get();
//当前线程池中线程个数是否小于corePoolSize ,小于则开启新线程运行任务
if (workerCountOf(c) < corePoolSize) {
//添加新的线程数,执行任务
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果线程池处于RUNNING状态,则添加任务到阻塞队列
if (isRunning(c) && workQueue.offer(command)) {
//再次检查
int recheck = ctl.get();
//如果状态不为RUNNING,从队列里删除该任务,执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 否则如果当前线程池为空则添加1个线程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//如果队列满新增线程
else if (!addWorker(command, false))
//如果新增失败则执行拒绝策略
reject(command);
}
新增线程的 addWorkd()方法
:第一部分双重循环的目的是通过 CAS 操作增加线程数:
第二部分主要是把并发安全的任务 加到 workers 里面,并且启动任务执行
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
// 检查队列是否只在必要时为空.
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
//循环CAS增加线程个数
for (;;) {
//如果线程个数超限则返回false
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
//CAS增加线程个数 ,同时只有一个线程成功
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// CAS 失败了,则看线程池状态是否变化了,变化则跳到外层循环重新尝试获取线程池
//状态,否则内层循环重新CAS
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
}
}
//到这里说明 CAS 添加线程成功了,开始添加worker 添加成功调用线程的start执行任务
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//创建worker
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//加独占锁,为了实现workers 同步,因为可能多个线程可能同时调用了线程池 execute
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 在锁定时重新检查.
// 在ThreadFactory失败时退出
// 在获得锁之前关闭
int c = ctl.get();
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
//添加worker
workers.add(w);
workerAdded = true;
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
//添加成功后则启动任务
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
新增线程后执行task任务调用 runWorker()方法
新增一个线程就会创建一个包装对象worker ;创建后 调用worker 的runWorker()方法来执行任务
该方法会while循环从阻塞队列里取task任务。getTask()方法会更具是核心线程还是非核心线程来执行不同的方法
核心线程执行workQueue.take()方法。该方法是当队列任务数 =0时执行contion.await()方法,该方法会时该线程一直等待;
非核心线程执行workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 。该方法是当队列任务数=0时执行超时等待方法 contion.awaitNanos(nanos) ,在使线程等待我们创建的线程池时设置的非核心线程的时间后,非核心线程不再等待,方法返回,非核心线程执行完毕结束销毁。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
/*当新建线程时,task 不为空,直接进入循环。当线程执行完该任务后task==null 然后执行getTask()方法从阻塞队列里获取task
*/
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
//执行任务的run方法 走getTask()
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保证下次还从阻塞队列的里取
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
//从阻塞队列获取任务
private Runnable getTask() {
//省略一些代码
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSE CONDS) //非核心线程执行poll方法,执行超时等待,保证无任务后销毁
:workQueue.take(); //核心线程执行take方法,一直等待保证核心线程不会销毁
}
//非核心线程的poll方法
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0) {
if (nanos <= 0)
return null;
nanos = notEmpty.awaitNanos(nanos); //执行超时等待,超时时间过后re
}
return dequeue(); //任务不为空 返回任务
} finally {
lock.unlock();
}
}
//核心线程的take方法
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();//一直等待
return dequeue(); //任务不为空 返回任务
} finally {
lock.unlock();
}
}