线程池核心参数
- corePoolSize：核心线程数
- maximumPoolSize：最大线程数
- keepAliveTime：线程最大空闲时间（默认针对非核心线程）
- unit：最大空闲时间的单位
- workQueue：阻塞队列
- threadFactory：线程工厂
- handler：拒绝策略
线程池任务处理流程
线程池执行任务的方法是execute方法，并传递任务。如果想看懂线程池的核心源码，需要查看的就是线程池的核心属性。
// 线程池的核心属性
/**
* 一个int类型的ctl，存储了线程池的两个核心属性
* 线程池状态：基于ctl的高三位存储
* 工作线程个数：基于ctl的低29位，存储工作线程，最大工作线程个数也就是2^29
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// Integer.SIZE = 32
private static final int COUNT_BITS = Integer.SIZE - 3;
// COUNT_MASK：就是2^29，也就是线程池中工作线程数的最大值
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
// 下面五个属性是线程池的状态
private static final int RUNNING = -1 << COUNT_BITS;
// 正常的接受，执行任务，正常处理工作队列的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 执行shutdown方法，从running变为shutdown状态。不接受新的任务，可以正常地处理任务（在变成shutdown之前接受到的任务）
// 可以正常处理工作队列的任务
// 空闲线程会被中断
private static final int STOP = 1 << COUNT_BITS;
// 执行shutdownNow方法才会从running变为stop状态。
// 不接受新的任务，正在执行任务的线程全部强制中断，（不一定停下来，但是中断标记位设置为ture）
// 工作队列的任务不处理，直接作为返回值
private static final int TIDYING = 2 << COUNT_BITS;
// 工作线程为0个并且工作队列任务处理完毕，才会从shutdown变为tidying状态
// 工作线程为0个，才会从stop状态变为tidying状态
// tidying状态为过渡状态
private static final int TERMINATED = 3 << COUNT_BITS;
// 执行terminated方法，从tidying状态变为terminated状态。线程池凉凉线程池的工作状态之间的关系可以用一张概括（线程池的生命周期）：
线程池的执行流程：
public void execute(Runnable command) { // command就是任务
// 非空检验
if (command == null)
throw new NullPointerException();
// 拿到存储线程池状态以及工作线程个数的核心属性
int c = ctl.get();
// 判断当前工作线程数是否小于核心线程数
if (workerCountOf(c) < corePoolSize) {
// 创建工作线程
// command：传递进来的任务
// true：创建核心线程，false：创建非核心线程
if (addWorker(command, true))
return;
c = ctl.get();
}
// 如果核心线程数已经达到预期的数值，任务就要扔到工作队列当中
// 如果线程池工作状态为running，直接将任务扔到工作队列当中
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);
}根据以上分析，线程池的处理流程为：核心 - 工作队列 - 非核心 - 拒绝策略。
创建工作线程池流程
- 判断线程池状态是否符合要求
- 判断工作线程个数是否符合要求，并且基于cas保证原子性
- new Worker创建工作线程，并将Worker对象添加到HashSet中，使用ReentrantLock保证安全
- 拿到Worker对象中的thread，执行start方法，启动线程
核心线程，非核心线程都是基于addWorker创建的。
private boolean addWorker(Runnable firstTask, boolean core) {
// 判断线程池的状态，再判断线程个数
// 外层for循环在判断线程池的状态，内层for循环在判断线程池的个数，然后基于cas修改ctl属性，给工作线程 + 1。
retry:
for (int c = ctl.get();;) {
// Check if queue empty only if necessary.
// 解决在shutdown状态下，没有工作线程，要构建一个线程处理工作队列任务的情况
if (runStateAtLeast(c, SHUTDOWN) // rs:高三位的线程池状态
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
// 如果线程状态没有问题，在判断线程个数
for (;;) {
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
// 为了避免多线程并发，导致破坏设置的核心参数
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 创建工作线程，启动工作线程
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null; // Worker对象就是你的工作线程
try {
//创建工作线程，并将任务交给Worker对象
w = new Worker(firstTask);
// 直接将new Worker对象时构建的Thread对象拿到
final Thread t = w.thread;
// 判断使用线程池的用户，指定的线程工厂构建的thread不是null
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 c = ctl.get();
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
// 加锁的原因是要对HashSet操作，HashSet不是线程安全的，不加锁不安全，
// 将工作线程添加到works，works是HashSet对象
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;
}工作队列Worker
线程池里面的工作线程就是Worker对象，查看一下Worker里面做了什么事情。
// Worker是一个工作线程，同时也会存储一个任务（只存储第一个任务）
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
@SuppressWarnings("serial")
final Thread thread;
@SuppressWarnings("serial")
Runnable firstTask;
Worker(Runnable firstTask) {
// 任务构建
this.firstTask = firstTask;
// 线程构建
this.thread = getThreadFactory().newThread(this);
}
// addWorker中执行thread.start方法后，执行的是Worker对象中的run方法
public void run() {
runWorker(this);
}
}AQS是JUC包下的一个并发基类，很多同步内容都是基于AQS实现的，比如：
- ReentrantLock
- ReentrantReadWriteLock
- CountDownLatch
- Semaphore
- 线程池中的Worker对象也是基于AQS做了一个实现.
Worker继承AQS干嘛？
Worker继承AQS后，可以使用CAS修改属性state，state算是一个标记位。
在shutdown状态下，空闲的线程要执行interrupt中断，正在工作状态的线程不能执行interrrupt。
工作线程执行任务之前，会先执行lock方法（将state从0改为1），正在工作的线程，state为1。
在中断线程之前，判断每一个线程的state，如果为0，直接interrupt，如果为1，什么也不干。
执行/拉取任务流程
- 执行任务
执行任务就是启动工作线程之后，执行了Worker对象的run方法，在run方法里面执行了runWorker方法。
final void runWorker(Worker w) {
// 拿到工作线程中的Thread
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// 判断线程池状态是不是stop
// 如果是stop，强制中断当前线程
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 钩子函数
beforeExecute(wt, task);
try {
// 执行任务
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
// 钩子函数
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}- 拉取任务
工作线程执行完自带的任务后，会直接基于getTask方法从阻塞队列中尝试拉取任务
// 线程正常的生命结束，就是run方法执行完毕
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
// 判断线程池工作状态，如果为stop，或者为shutdown并且工作队列任务都处理完毕，
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
// 工作线程个数 - 1，结束当前线程
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 核心线程执行take，非核心线程执行poll（poll方法拉取最大空闲时间）
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
try {
Runnable r = timed ?
// poll方法拉取阻塞队列任务，指定keepAliveTime
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
// take方法，死等任务，直到中断
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}线程池关闭
shutdown方法：
- 将线程池状态修改为shutdown
- 将空闲的工作线程直接中断
- 再确认工作队列中的任务全部处理完，并且工作线程个数为0，自动改为tidying状态
- 在tidying状态下，执行terminated方法，变为terminated状态
- 线程池结束
shutdwonNow方法：
- 将线程池状态改为stop
- 将所有的工作线程直接中断
- 在工作线程个数为0，自动改为tidying状态
- 在tidying状态下，执行terminated方法，变为terminated状态
- 线程池结束
// 优雅地关闭线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown();
} finally {
mainLock.unlock();
}
tryTerminate();
}在工作中，核心线程数，最大线程数，空闲时间怎么设置？任务队列怎么设置比较好？
如果为了充分的发挥硬件的性能，一般只考虑三个参数：
- 核心线程数：最终要的属性，根据业务类型判断设置多少合适
- CPU密集型任务：线程一直在干活，不希望cpu做上下文切换
- IO密集型任务：因为线程干一会，歇一会
- 混合型任务：偶尔要求cpu一直调度，偶尔不干活，可以切换
- 想要设置号核心线程数，去充分发挥服务器的性能，需要动态地调试和压测。为了避免调试参数时，反复重启，成本太高，可以设置动态线程池，线程池提供了set方法设置核心参数，get方法查看核心参数。可以在压测时，根据cpu使用情况来调整核心线程个数
- 工作队列长度：根据服务器的内存使用情况来调试，同时也要查看JVM的堆内存大小
- 拒绝策略：根据任务来决定，如果任务就是写个日志啥的，就直接扔了，如果任务时必须要执行的，那就重试，或者存储到数据库，后期统一做补偿操作。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
