目录
线程池是什么？
线程池（Thread Pool）是一种基于池化思想管理线程的工具，在现在的系统中，线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。
当然，使用线程池可以带来一系列好处：
- 降低资源消耗：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。
- 提高响应速度：任务到达时，无需等待线程创建即可立即执行。
- 提高线程的可管理性：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。
- 提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。
线程池的总体设计
①顶层接口Executor：其提供了一种思想，将任务提交和任务执行解耦，用户无需关注如何创建线程，如何调度线程执行任务，只需要提供一个Runnable对象即可
②ExecutorService：在上层的基础之上补充了执行任务的能力和管控线程池的方法，比如关闭TP
③AbstractExecutorService：将执行任务的流程串联起来，保证下层的实现只需要关注一个执行任务的方法即可
④ThreadPoolExecutor：就是我们直接使用的一个类
线程池的七大核心参数
①核心线程数corePoolSize：线程池中最小的线程数，即使是空闲状态也不会被销毁，除非手动设置了超时时间(allowCoreThreadTimeout=true)
②最大线程数maximumPoolSize：线程池中允许的最大线程数，当workerCount超过corePoolSize并且工作队列已经满了的情况下，会创建非核心线程，总体数量不超过maximunPoolSize
③工作队列workQueue：当workerCount大于corePoolSize并且工作队列还有容量会放到队列中等待线程执行，（ArrayBlokingQueue：基于数组的有界阻塞队列；LinkedBlokingQueue：基于链表的有界阻塞队列；SyschronousQueue：不存储元素的阻塞队列）
④线程空闲时间keepAliveTime：非核心线程超过空闲时间会被JVM回收销毁
⑤时间单位unit：线程空闲时间时间单位
⑥线程工厂threadFactory：用来创建新线程，可以设置线程的名字以及是否为守护线程
⑦拒绝/饱和策略handler：当workerCount>maximumPoolSize之后，线程池不能再接受任务，此时先任务再进来就会执行拒绝策略，（AbortPolicy：抛出异常；CallerRunspolicy：让任务调用者运行该任务；DiscardPolicy：直接丢弃掉；DiscradOldestPolicy：丢弃最老的任务）
线程池的执行过程
①首先当我们提交一个任务之后，首先会判断线程池的状态runState是否为Running,如果不是的话会被直接拒绝
②然后回判断workerCount是否小于corePoolSize，如果小于的话，会直接创建一个核心线程来执行任务
③如果workerCount大于corePoolSize，但是工作队列容量还没满，就会将任务放在工作队列中等待线程来执行
④如果workerCount大于corePoolSize，并且工作队列容量也满了的话，再去看workerCount是否小于maximumPoolSize，如果小于的话则会创建非核心线程来执行任务
⑤如果此时workerCount已经大于等于maximumPoolSize的话，则会执行拒绝策略来处理新任务
线程池的生命周期
在讲生命周期之前，需要知道线程池内部的一个存储生命周期和线程数量的一个变量。
ctl这个AtomicInteger类型，是对线程池的运行状态和线程池中有效线程的数量进行控制的一个字段， 它同时包含两部分的信息：线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，高3位保存runState，低29位保存workerCount，两个变量之间互不干扰。用一个变量去存储两个值，可避免在做相关决策时，出现不一致的情况，不必为了维护两者的一致，而占用锁资源。通过阅读线程池源代码也可以发现，经常出现要同时判断线程池运行状态和线程数量的情况。线程池也提供了若干方法去供用户获得线程池当前的运行状态、线程个数。这里都使用的是位运算的方式，相比于基本运算，速度也会快很多。
线程池的线程创建、任务申请、任务执行、回收销毁
线程创建
线程池的线程创建是通过addWorker(Runnable firstTask，boolean core)方法创建，firstTask可为null，用于指定线程的第一个任务。core表示是否为核心线程。
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;
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 {
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;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}任务申请
如果线程创建时带有firstTask，则先执行firstTask，否则就与其他线程一样通过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.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}任务执行
当线程申请到任务之后，执行runWorker()方法执行任务，期间会通过AQS的非重入锁进行加锁执行
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 pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
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 {
processWorkerExit(w, completedAbruptly);
}
}线程回收
在此推荐阅读美团技术团队的原文章：
扫一扫
1920
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
