corePoolSize 核心线程数:如果当前的线程数少于corePoolSize,则创建新线程来处理任务。
maximumPoolSize 允许的最大线程数:如果队列满了并且线程少于maximumPoolSize,线程池仍旧会创建新的线程来处理
keepAliveTime 非核心线程限制的超时时间:超过这个时间就回收
unit TimeUtil 时间单位
workQueue 等待队列
threadFactory 线程创建工厂
handler 拒绝策略
线程池的原理:一种处理任务的策略
给线程池提交任务,如果当前的执行任务的线程数少于核心线程数,则创建新线程来处理任务,如果创建的线程数到达核心线程数,那么就把任务存到阻塞队列当中,如果队列也满了,然后判断
当前的线程数小于最大线程数,那么创建非核心线程来执行任务。如果当前线程数大于或者等于最大线程数,则执行饱和策略。
线程池的状态
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;
线程池处理任务的函数
execute(Runnable command){
if(workerCountOf(ctl.get() < corePoolSize)){// 少于核心线程数
if(addWorker(command,true))// 循环CAS操作将线程计数增加一,新建一个线程并启用
return;
c = ctl.get();
}
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);
}
private boolean addWorker(Runnable firstTask, boolean core) {
//(1)循环CAS操作,将线程池中的线程数+1.
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);
//core true代表是往核心线程池中增加线程 false代表往最大线程池中增加线程
//线程数超标,不能再添加了,直接返回
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//CAS修改clt的值+1,在线程池中为将要添加的线程流出空间,成功退出cas循环,失败继续
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//如果线程池的状态发生了变化回到retry外层循环
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//(2)新建线程,并加入到线程池workers中。
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//对workers操作要通过加锁来实现
final ReentrantLock mainLock = this.mainLock;
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//细化锁的力度,防止临界区过大,浪费时间
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
int rs = runStateOf(c);
//判断线程池的状态
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();//(3)
workerStarted = true;
}
}
} finally {
//线程添加线程池失败或者线程start失败,则需要调用addWorkerFailed函数,
//如果添加成功则需要移除,并回复clt的值
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}