为什么要使用线程池
-
减少线程实例的创建和销毁，使线程能够重用，提高系统性能
-
可以根据系统的承受能力，调整线程池中工作线程的数量，防止线程消耗过多内存导致服务器崩溃
线程池的实现原理
-
判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
-
线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
-
判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。
流程图如下
image
JDK原生线程池的创建
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
参数说明
-
corePoolSize：线程池核心线程数量
-
maximumPoolSize:线程池最大线程数量
-
keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间
-
unit：存活时间的单位
-
workQueue：存放任务的队列
-
handler：超出线程范围和队列容量的任务的处理程序
线程池的源码解读
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
* 进行下面三步
*
* 1. 如果运行的线程小于corePoolSize,则尝试使用用户定义的Runnalbe对象创建一个新的线程
* 调用addWorker函数会原子性的检查runState和workCount，通过返回false来防止在不应
* 该添加线程时添加了线程
* 2. 如果一个任务能够成功入队列，在添加一个线城时仍需要进行双重检查（因为在前一次检查后
* 该线程死亡了），或者当进入到此方法时，线程池已经shutdown了，所以需要再次检查状态，
* 若有必要，当停止时还需要回滚入队列操作，或者当线程池没有线程时需要创建一个新线程
* 3. 如果无法入队列，那么需要增加一个新线程，如果此操作失败，那么就意味着线程池已经shut
* down或者已经饱和了，所以拒绝任务
*/
// 获取线程池控制状态
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) { //worker数量小于corePoolSize
if (addWorker(command, true))
return;
// 不成功则再次获取线程池控制状态
c = ctl.get();
}
// 线程池处于RUNNING状态，将命令（用户自定义的Runnable对象）添加进workQueue队列
if (isRunning(c) && workQueue.offer(command)) {
// 再次检查，获取线程池控制状态
int recheck = ctl.get();
// 线程池不处于RUNNING状态，将命令从workQueue队列中移除
if (! isRunning(recheck) && remove(command))
reject(command);// 拒绝执行命令
else if (workerCountOf(recheck) == 0)// worker数量等于0
// 添加worker
addWorker(null, false);
}
// 添加worker失败
else if (!addWorker(command, false))
reject(command);// 拒绝执行命令
}
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 && // 状态大于等于SHUTDOWN，初始的ctl为RUNNING，小于SHUTDOWN
! (rs == SHUTDOWN && // 状态为SHUTDOWN
firstTask == null && // 第一个任务为null
! workQueue.isEmpty())) // worker队列不为空
// 返回
return false;
for (;;) {
// worker数量
int wc = workerCountOf(c);
if (wc >= CAPACITY || // worker数量大于等于最大容量
wc >= (core ? corePoolSize : maximumPoolSize)) // worker数量大于等于核心线程池大小或者最大线程池大小
return false;
if (compareAndIncrementWorkerCount(c)) // 比较并增加worker的数量
// 跳出外层循环
break retry;
// 获取线程池控制状态
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs) // 此次的状态与上次获取的状态不相同
// 跳过剩余部分，继续循环
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// worker开始标识
boolean workerStarted = false;
// worker被添加标识
boolean workerAdded = false;
//
Worker w = null;
try {
// 初始化worker
w = new Worker(firstTask);
// 获取worker对应的线程
final Thread t = w.thread;
if (t != null) { // 线程不为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 || // 小于SHUTDOWN
(rs == SHUTDOWN && firstTask == null)) { // 等于SHUTDOWN并且firstTask为null
if (t.isAlive()) // precheck that t is startable // 线程刚添加进来，还未启动就存活
// 抛出线程状态异常
throw new IllegalThreadStateException();
// 将worker添加到worker集合
workers.add(w);
// 获取worker集合的大小
int s = workers.size();
if (s > largestPoolSize) // 队列大小大于largestPoolSize
// 重新设置largestPoolSize
largestPoolSize = s;
// 设置worker已被添加标识
workerAdded = true;
}
} finally {
// 释放锁
mainLock.unlock();
}
if (workerAdded) { // worker被添加
// 开始执行worker的run方法
t.start();
// 设置worker已开始标识
workerStarted = true;
}
}
} finally {
if (! workerStarted) // worker没有开始
// 添加worker失败
addWorkerFailed(w);
}
return workerStarted;
}
说明：此函数可能会完成如下几件任务
-
原子性的增加workerCount。
-
将用户给定的任务封装成为一个worker，并将此worker添加进workers集合中。
-
启动worker对应的线程，并启动该线程，运行worker的run方法。
-
回滚worker的创建动作，即将worker从workers集合中删除，并原子性的减少workerCount。
我们通过一个程序来观察线程池的工作原理：
public class ThreadPoolTest {
public static void main(String[] args) {
BlockingQueue<Runnable> blockingQueue = new LinkedBlockingDeque<>(5);
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, blockingQueue);
for (int i = 0; i < 10; i++) {
threadPoolExecutor.execute(() -> {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("线程池中活跃的线程数： " + threadPoolExecutor.getPoolSize());
if (blockingQueue.size() > 0) {
System.out.println("----------------队列中阻塞的线程数" + blockingQueue.size());
}
}
}
}
执行结果如下
线程池中活跃的线程数： 1
线程池中活跃的线程数： 2
线程池中活跃的线程数： 3
线程池中活跃的线程数： 4
线程池中活跃的线程数： 5
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数1
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数2
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数3
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数4
线程池中活跃的线程数： 5
----------------队列中阻塞的线程数5
线程池中活跃的线程数： 6
----------------队列中阻塞的线程数5
线程池中活跃的线程数： 7
----------------队列中阻塞的线程数5
线程池中活跃的线程数： 8
----------------队列中阻塞的线程数5
线程池中活跃的线程数： 9
----------------队列中阻塞的线程数5
线程池中活跃的线程数： 10
----------------队列中阻塞的线程数5
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task thread.ThreadPoolTest$$Lambda$1/1313922862@27bc2616 rejected from java.util.concurrent.ThreadPoolExecutor@3941a79c[Running, pool size = 10, active threads = 10, queued tasks = 5, completed tasks = 0]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
at thread.ThreadPoolTest.main(ThreadPoolTest.java:18)
从结果可以观察出：
-
创建的线程池具体配置为：核心线程数量为5个；全部线程数量为10个；工作队列的长度为5。
-
我们通过queue.size()的方法来获取工作队列中的任务数。
-
运行原理：
刚开始都是在创建新的线程，达到核心线程数量5个后，新的任务进来后不再创建新的线程，而是将任务加入工作队列，任务队列到达上线5个后，新的任务又会创建新的普通线程，直到达到线程池最大的线程数量10个，后面的任务则根据配置的饱和策略来处理。我们这里没有具体配置，使用的是默认的配置AbortPolicy:直接抛出异常。
当然，为了达到我需要的效果，上述线程处理的任务都是利用休眠导致线程没有释放！！！
RejectedExecutionHandler：饱和策略
$ 队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy，表示无法处理新的任务而抛出异常。JAVA提供了4中策略：
-
AbortPolicy：直接抛出异常
-
CallerRunsPolicy：只用调用所在的线程运行任务
-
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
-
DiscardPolicy：不处理，丢弃掉。
网友评论