池化思想
我们在日常的开发中肯定有接触过很多的池化技术,譬如 数据库连接池,redis连接池,包括我们今天想和大家分享的线程池,其实这些池化技术的核心思想都是空间换时间 以及复用的思想 能够尽最大的可能减少建立链接的资源消耗从而使我们的程序响应时间缩短。
什么是线程池？
线程池是JDK为我们提供的一种开箱即用的池化技术,能够帮我们减少线程创建的开销,在我们初始化线程池的时候他就会按照我们指定的核心线程数,帮我们初始化好一些处于处于运行态的worker等待接受我们的任务 当我们向线程池中添加任务的时候直接进行任务的处理 无需频繁的进行线程的创建 并且维护一个阻塞队列用于对我们的任务进行缓存 今天就让我们一起来揭开他的神秘面纱！
创建一个线程池
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
当我们创建一个线程池的时候我们首先需要明确我们的核心线程数 也就是我们在初始化线程池的时候需要先跑起来多少个线程 接下来我们需要明确我们最多可以创建多少个线程 防止我们创建过多的线程造成OOM 第三个参数也就是我们需要执行 非核心线程的一个生存周期 也就是当我们这个worker持续多少时间没有任务的时候需要去 终止非核心线程 第四个参数也就是我们的阻塞队列 用于缓存我们的任务 最后一个我们需要传递的是当线程池中的队列满了 并且线程数已经达到了最大的线程数量这个时候要触发的拒绝策略 这个我们在后面回去讲到
线程池怎么标志当前的状态以及当前的线程数？
线程池预热 启动所有的核心线程
public boolean prestartCoreThread() {
//如果当前的 worker的数量小于当前配置的核心线程数的数量则 添加worker
return workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
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.
//如果当前的状态不是运行中
// 或者是当前的线程池不是shutdowm状态并且队列中还有任务
//就直接返回false
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//死循环
for (;;) {
//获取当前线程池中的worker数量
int wc = workerCountOf(c);
//如果当前创建的是核心线程则判断是不是超过了核心线程
// 否则判断当前是不是超过了最大的线程数
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//CAS 增加worker的数量
if (compareAndIncrementWorkerCount(c))
break retry;
//重新获取ctl重新循环
c = ctl.get(); // Re-read ctl
//如果状态改变重新外层的循环
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//CAS 成功
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 {
//获取当前的运行状态
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//添加到worker队列
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//启动worker线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
开始添加执行任务
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
//如果当前的worker数量小于核心线程数直接创建一个worker去处理 将当前任务作为当前worker的第一个任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
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);
}
//如果队列满了 并且worker也超过了最大的线程数 执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
四种拒绝策略
- 由原线程处理
- 直接抛出异常【默认】
- 直接丢弃
- 丢弃队列中最早的任务
worker 如何执行任务的
final void runWorker(Worker w) {
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();
//中断线程处理
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 {
//线程退出 这里是当获取任务为null的时候会执行
processWorkerExit(w, completedAbruptly);
}
}
获取任务 getTask()
private Runnable getTask() {
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.
//如果当前线程池的状态大于shutdown 则CAS减少当前的worker数量并返回null 用于后续的processExit()
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
//获取当前worker的数量
int wc = workerCountOf(c);
// 判断是不是允许核心线程的超时 或者当前线程数量大于核心线程数 都会触发线程worker的退出
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//如果 worker的数量大于最大线程的数量或者上次获取任务超时 并且 任务队列中没有任务了 CAS 减少worker数量 返回null
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//如果有 设置keepAliveTime 超时获取任务否则阻塞获取
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
//设置超时flag
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
线程退出
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
//CAS WORKER COUNT--
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//已经完成的任务数量统计
completedTaskCount += w.completedTasks;
//移除当前worker
workers.remove(w);
} finally {
mainLock.unlock();
}
//尝试退出
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
结语
这篇文章主要是简单的和大家分享了一下 线程池的基本构造 关于线程池的更多细节 还需要大家去深入的了解 主要是给大家梳理一下主要的脉络 如果有哪些不对的地方希望大家不吝赐教 感谢!
