Java提升班（二）深刻理解线程池ThreadPool
本文你将得到如下信息：html
- 线程池源码解读
- 线程池执行流程分析
- 带返回值的线程池实现
- 延迟线程池实现
为了方便读者理解，本文会由浅入深，先从线程池的使用开始再延伸到源码解读和源码分析等高级内容，读者可根据本身的状况自主选择阅读顺序和须要了解的章节。java
1、线程池优势
线程池可以更加充分的利用CPU、内存、网络、IO等系统资源，线程池的主要做用以下：git
- 利用线程池能够复用线程，控制最大并发数；
- 实现任务缓存策略和拒绝机制；
- 实现延迟执行
阿里巴巴Java开发手册强制规定：线程资源必须经过线程池提供，以下图：github
2、线程池使用
本节会介绍7种线程池的建立与使用，线程池的状态介绍，ThreadPoolExecutor参数介绍等。算法
2.1 线程池建立
线程池可使用Executors和ThreadPoolExecutor，其中使用Executors有六种建立线程池的方法，以下图：api
// 使用Executors方式建立 ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2); ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor(); ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2); ExecutorService workStealingPool = Executors.newWorkStealingPool(); // 原始建立方式 ThreadPoolExecutor tp = new ThreadPoolExecutor(10, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
2.1.1 线程池解读
- newSingleThreadExecutor()，它的特色在于工做线程数目被限制为 1，操做一个无界的工做队列，因此它保证了全部任务的都是被顺序执行，最多会有一个任务处于活动状态，而且不容许使用者改动线程池实例，所以能够避免其改变线程数目。
- newCachedThreadPool()，它是一种用来处理大量短期工做任务的线程池，具备几个鲜明特色：它会试图缓存线程并重用，当无缓存线程可用时，就会建立新的工做线程；若是线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 做为工做队列。
- newFixedThreadPool(int nThreads)，重用指定数目（nThreads）的线程，其背后使用的是无界的工做队列，任什么时候候最多有 nThreads 个工做线程是活动的。这意味着，若是任务数量超过了活动队列数目，将在工做队列中等待空闲线程出现；若是有工做线程退出，将会有新的工做线程被建立，以补足指定的数目 nThreads。
- newSingleThreadScheduledExecutor() 建立单线程池，返回 ScheduledExecutorService，能够进行定时或周期性的工做调度。
- newScheduledThreadPool(int corePoolSize)和newSingleThreadScheduledExecutor()相似，建立的是个 ScheduledExecutorService，能够进行定时或周期性的工做调度，区别在于单一工做线程仍是多个工做线程。
- newWorkStealingPool(int parallelism)，这是一个常常被人忽略的线程池，Java 8 才加入这个建立方法，其内部会构建ForkJoinPool，利用Work-Stealing算法，并行地处理任务，不保证处理顺序。
- ThreadPoolExecutor是最原始的线程池建立，上面1-3建立方式都是对ThreadPoolExecutor的封装。
总结： 其中newSingleThreadExecutor、newCachedThreadPool、newFixedThreadPool是对ThreadPoolExecutor的封装实现，newSingleThreadScheduledExecutor、newScheduledThreadPool则为ThreadPoolExecutor子类ScheduledThreadPoolExecutor的封装，用于执行延迟任务，newWorkStealingPool则为Java 8新加的方法。缓存
2.1.2 单线程池的意义
从以上代码能够看出newSingleThreadExecutor和newSingleThreadScheduledExecutor建立的都是单线程池，那么单线程池的意义是什么呢？网络
虽然是单线程池，但提供了工做队列，生命周期管理，工做线程维护等功能。并发
2.2 ThreadPoolExecutor解读
ThreadPoolExecutor做为线程池的核心方法，咱们来看一下ThreadPoolExecutor内部实现，以及封装类是怎么调用ThreadPoolExecutor的。oracle
先从构造函数提及，构造函数源码以下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
参数说明：
- corePoolSize：所谓的核心线程数，能够大体理解为长期驻留的线程数目（除非设置了 allowCoreThreadTimeOut）。对于不一样的线程池，这个值可能会有很大区别，好比 newFixedThreadPool 会将其设置为 nThreads，而对于 newCachedThreadPool 则是为 0。
- maximumPoolSize：顾名思义，就是线程不够时可以建立的最大线程数。一样进行对比，对于 newFixedThreadPool，固然就是 nThreads，由于其要求是固定大小，而 newCachedThreadPool 则是 Integer.MAX_VALUE。
- keepAliveTime：空闲线程的保活时间，若是线程的空闲时间超过这个值，那么将会被关闭。注意此值生效条件必须知足：空闲时间超过这个值，而且线程池中的线程数少于等于核心线程数corePoolSize。固然核心线程默认是不会关闭的，除非设置了allowCoreThreadTimeOut(true)那么核心线程也能够被回收。
- TimeUnit：时间单位。
- BlockingQueue：任务丢列，用于存储线程池的待执行任务的。
- threadFactory：用于生成线程，通常咱们能够用默认的就能够了。
- handler：当线程池已经满了，可是又有新的任务提交的时候，该采起什么策略由这个来指定。有几种方式可供选择，像抛出异常、直接拒绝而后返回等，也能够本身实现相应的接口实现本身的逻辑。
来看一下线程池封装类对于ThreadPoolExecutor的调用：
newSingleThreadExecutor对ThreadPoolExecutor的封装源码以下：
public static ExecutorService newSingleThreadExecutor() {
return new Executors.FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
newCachedThreadPool对ThreadPoolExecutor的封装源码以下：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
newFixedThreadPool对ThreadPoolExecutor的封装源码以下：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
ScheduledExecutorService对ThreadPoolExecutor的封装源码以下：
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}
newSingleThreadScheduledExecutor使用的是ThreadPoolExecutor的子类ScheduledThreadPoolExecutor，以下图所示：
newScheduledThreadPool对ThreadPoolExecutor的封装源码以下：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
newScheduledThreadPool使用的也是ThreadPoolExecutor的子类ScheduledThreadPoolExecutor。
2.3 线程池状态
查看ThreadPoolExecutor源码可知线程的状态以下：
线程状态解读（如下内容来源于：https://javadoop.com/post/java-thread-pool）：
- RUNNING：这个没什么好说的，这是最正常的状态：接受新的任务，处理等待队列中的任务；
- SHUTDOWN：不接受新的任务提交，可是会继续处理等待队列中的任务；
- STOP：不接受新的任务提交，再也不处理等待队列中的任务，中断正在执行任务的线程；
- TIDYING：全部的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()；
- TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个；
RUNNING 定义为 -1，SHUTDOWN 定义为 0，其余的都比 0 大，因此等于 0 的时候不能提交任务，大于 0 的话，连正在执行的任务也须要中断。
看了这几种状态的介绍，读者大致也能够猜到十之八九的状态转换了，各个状态的转换过程有如下几种：
- RUNNING -> SHUTDOWN：当调用了 shutdown() 后，会发生这个状态转换，这也是最重要的；
- (RUNNING or SHUTDOWN) -> STOP：当调用 shutdownNow() 后，会发生这个状态转换，这下要清楚 shutDown() 和 shutDownNow() 的区别了；
- SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING；
- STOP -> TIDYING：当任务队列清空后，发生这个转换；
- TIDYING -> TERMINATED：这个前面说了，当 terminated() 方法结束后；
2.4 线程池执行
说了那么多下来一块儿来看线程池的是怎么执行任务的，线程池任务提交有两个方法：
- execute
- submit
其中execute只能接受Runnable类型的任务，使用以下：
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
submit能够接受Runnable或Callable类型的任务，使用以下：
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
2.4.1 带返回值的线程池实现
使用submit传递Callable类能够获取执行任务的返回值，Callable是JDK 1.5 添加的特性用于补充Runnable无返回的状况。
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Long> result = executorService.submit(new Callable<Long>() {
@Override
public Long call() throws Exception {
return new Date().getTime();
}
});
try {
System.out.println("运行结果：" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
2.4.2 延迟线程池实现
在线程池中newSingleThreadScheduledExecutor和newScheduledThreadPool返回的是ScheduledExecutorService，用于执行延迟线程池的，代码以下：
// 延迟线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("time:" + new Date().getTime());
}
}, 10, TimeUnit.SECONDS);
完整示例下载地址： https://github.com/vipstone/java-core-example
3、线程池源码解读
阅读线程池的源码有一个小技巧，能够按照线程池执行的顺序进行串连关联阅读，这样更容易理解线程池的实现。
源码阅读流程解读
咱们先从线程池的任务提交方法execute()开始阅读，从execute()咱们会发现线程池执行的核心方法是addWorker()，在addWorker()中咱们发现启动线程调用了start()方法，调用start()方法以后会执行Worker类的run()方法，run里面调用runWorker()，运行程序的关键在于getTask()方法，getTask()方法以后就是此线程的关闭，整个线程池的工做流程也就完成了，下来一块儿来看吧（若是本段文章没看懂的话也能够看完源码以后，回过头来再看一遍）。
3.1 execute() 源码解读
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 若是当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，
// 建立一个新的线程，并把当前任务 command 做为这个线程的第一个任务(firstTask)
if (workerCountOf(c) < corePoolSize) {
// 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就能够返回了
// 至于执行的结果，到时候会包装到 FutureTask 中。
// 返回 false 表明线程池不容许提交任务
if (addWorker(command, true))
return;
c = ctl.get();
}
// 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
// 若是线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中
if (isRunning(c) && workQueue.offer(command)) {
/* 这里面说的是，若是任务进入了 workQueue，咱们是否须要开启新的线程
* 由于线程数在 [0, corePoolSize) 是无条件开启新的线程
* 若是线程数已经大于等于 corePoolSize，那么将任务添加到队列中，而后进到这里
*/
int recheck = ctl.get();
// 若是线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，而且执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 若是线程池仍是 RUNNING 的，而且线程数为 0，那么开启新的线程
// 到这里，咱们知道了，这块代码的真正意图是：担忧任务提交到队列中了，可是线程都关闭了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 若是 workQueue 队列满了，那么进入到这个分支
// 以 maximumPoolSize 为界建立新的 worker，
// 若是失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
else if (!addWorker(command, false))
reject(command);
}
3.2 addWorker() 源码解读
// 第一个参数是准备提交给这个线程执行的任务，以前说了，能够为 null
// 第二个参数为 true 表明使用核心线程数 corePoolSize 做为建立线程的界线，也就说建立这个线程的时候，
// 若是线程池中的线程总数已经达到 corePoolSize，那么不能响应此次建立线程的请求
// 若是是 false，表明使用最大线程数 maximumPoolSize 做为界线
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 这个很是很差理解
// 若是线程池已关闭，并知足如下条件之一，那么不建立新的 worker：
// 1. 线程池状态大于 SHUTDOWN，其实也就是 STOP, TIDYING, 或 TERMINATED
// 2. firstTask != null
// 3. workQueue.isEmpty()
// 简单分析下：
// 仍是状态控制的问题，当线程池处于 SHUTDOWN 的时候，不容许提交任务，可是已有的任务继续执行
// 当状态大于 SHUTDOWN 时，不容许提交任务，且中断正在执行的任务
// 多说一句：若是线程池处于 SHUTDOWN，可是 firstTask 为 null，且 workQueue 非空，那么是容许建立 worker 的
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;
// 因为有并发，从新再读取一下 ctl
c = ctl.get();
// 正常若是是 CAS 失败的话，进到下一个里层的for循环就能够了
// 但是若是是由于其余线程的操做，致使线程池的状态发生了变动，若有其余线程关闭了这个线程池
// 那么须要回到外层的for循环
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/*
* 到这里，咱们认为在当前这个时刻，能够开始建立线程来执行任务了，
* 由于该校验的都校验了，至于之后会发生什么，那是之后的事，至少当前是知足条件的
*/
// worker 是否已经启动
boolean workerStarted = false;
// 是否已将这个 worker 添加到 workers 这个 HashSet 中
boolean workerAdded = false;
Worker w = null;
try {
final ReentrantLock mainLock = this.mainLock;
// 把 firstTask 传给 worker 的构造方法
w = new Worker(firstTask);
// 取 worker 中的线程对象，以前说了，Worker的构造方法会调用 ThreadFactory 来建立一个新的线程
final Thread t = w.thread;
if (t != null) {
// 这个是整个类的全局锁，持有这个锁才能让下面的操做“瓜熟蒂落”，
// 由于关闭一个线程池须要这个锁，至少我持有锁的期间，线程池不会被关闭
mainLock.lock();
try {
int c = ctl.get();
int rs = runStateOf(c);
// 小于 SHUTTDOWN 那就是 RUNNING，这个自没必要说，是最正常的状况
// 若是等于 SHUTDOWN，前面说了，不接受新的任务，可是会继续执行等待队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// worker 里面的 thread 可不能是已经启动的
if (t.isAlive())
throw new IllegalThreadStateException();
// 加到 workers 这个 HashSet 中
workers.add(w);
int s = workers.size();
// largestPoolSize 用于记录 workers 中的个数的最大值
// 由于 workers 是不断增长减小的，经过这个值能够知道线程池的大小曾经达到的最大值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 添加成功的话，启动这个线程
if (workerAdded) {
// 启动线程
t.start();
workerStarted = true;
}
}
} finally {
// 若是线程没有启动，须要作一些清理工做，如前面 workCount 加了 1，将其减掉
if (! workerStarted)
addWorkerFailed(w);
}
// 返回线程是否启动成功
return workerStarted;
}
在这段代码能够看出，调用了t.start();
3.3 runWorker() 源码解读
根据上面代码可知，调用了Worker的t.start()以后，紧接着会调用Worker的run()方法，run()源码以下：
public void run() {
runWorker(this);
}
runWorker()源码以下：
// worker 线程启动后调用,while 循环(即自旋!)不断从等待队列获取任务并执行
// worker 初始化时，可指定 firstTask，那么第一个任务也就能够不须要从队列中获取
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
// 该线程的第一个任务(如有)
Runnable task = w.firstTask;
w.firstTask = null;
// 容许中断
w.unlock();
boolean completedAbruptly = true;
try {
// 循环调用 getTask 获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
// 若线程池状态大于等于 STOP，那么意味着该线程也要中断
/**
* 若线程池STOP，请确保线程 已被中断
* 若是没有，请确保线程未被中断
* 这须要在第二种状况下进行从新检查，以便在关中断时处理shutdownNow竞争
*/
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) {
// 这里不容许抛出 Throwable，因此转换为 Error
thrown = x; throw new Error(x);
} finally {
// 也是一个钩子方法，将 task 和异常做为参数，留给须要的子类实现
afterExecute(task, thrown);
}
} finally {
// 置空 task，准备 getTask 下一个任务
task = null;
// 累加完成的任务数
w.completedTasks++;
// 释放掉 worker 的独占锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 到这里，须要执行线程关闭
// 1. 说明 getTask 返回 null，也就是说，这个 worker 的使命结束了，执行关闭
// 2. 任务执行过程当中发生了异常
// 第一种状况，已经在代码处理了将 workCount 减 1，这个在 getTask 方法分析中说
// 第二种状况，workCount 没有进行处理，因此须要在 processWorkerExit 中处理
processWorkerExit(w, completedAbruptly);
}
}
3.4 getTask() 源码解读
runWorker里面的有getTask()，来看下具体的实现：
// 此方法有三种可能
// 1. 阻塞直到获取到任务返回。默认 corePoolSize 以内的线程是不会被回收的，它们会一直等待任务
// 2. 超时退出。keepAliveTime 起做用的时候，也就是若是这么多时间内都没有任务，那么应该执行关闭
// 3. 若是发生了如下条件，须返回 null
// 池中有大于 maximumPoolSize 个 workers 存在(经过调用 setMaximumPoolSize 进行设置)
// 线程池处于 SHUTDOWN，并且 workQueue 是空的，前面说了，这种再也不接受新的任务
// 线程池处于 STOP，不只不接受新的线程，连 workQueue 中的线程也再也不执行
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
// 容许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭
// 这里 break，是为了避免往下执行后一个 if (compareAndDecrementWorkerCount(c))
// 两个 if 一块儿看：若是当前线程数 wc > maximumPoolSize，或者超时，都返回 null
// 那这里的问题来了，wc > maximumPoolSize 的状况，为何要返回 null？
// 换句话说，返回 null 意味着关闭线程。
// 那是由于有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了
// 若是此 worker 发生了中断，采起的方案是重试
// 解释下为何会发生中断，这个读者要去看 setMaximumPoolSize 方法，
// 若是开发者将 maximumPoolSize 调小了，致使其小于当前的 workers 数量，
// 那么意味着超出的部分线程要被关闭。从新进入 for 循环，天然会有部分线程会返回 null
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// CAS 操做，减小工做线程数
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) {
// 若是此 worker 发生了中断，采起的方案是重试
// 解释下为何会发生中断，这个读者要去看 setMaximumPoolSize 方法，
// 若是开发者将 maximumPoolSize 调小了，致使其小于当前的 workers 数量，
// 那么意味着超出的部分线程要被关闭。从新进入 for 循环，天然会有部分线程会返回 null
timedOut = false;
}
}
}
4、线程池执行流程
线程池的执行流程以下图：
5、总结
本文总结以问答的形式展现，引自《深度解读 java 线程池设计思想及源码实现》，最下方附参考地址。
一、线程池有哪些关键属性？
corePoolSize 到 maximumPoolSize 之间的线程会被回收，固然 corePoolSize 的线程也能够经过设置而获得回收（allowCoreThreadTimeOut(true)）。
workQueue 用于存听任务，添加任务的时候，若是当前线程数超过了 corePoolSize，那么往该队列中插入任务，线程池中的线程会负责到队列中拉取任务。
keepAliveTime 用于设置空闲时间，若是线程数超出了 corePoolSize，而且有些线程的空闲时间超过了这个值，会执行关闭这些线程的操做
rejectedExecutionHandler 用于处理当线程池不能执行此任务时的状况，默认有抛出 RejectedExecutionException 异常、忽略任务、使用提交任务的线程来执行此任务和将队列中等待最久的任务删除，而后提交此任务这四种策略，默认为抛出异常。
二、线程池中的线程建立时机？
若是当前线程数少于 corePoolSize，那么提交任务的时候建立一个新的线程，并由这个线程执行这个任务；
若是当前线程数已经达到 corePoolSize，那么将提交的任务添加到队列中，等待线程池中的线程去队列中取任务；
若是队列已满，那么建立新的线程来执行任务，须要保证池中的线程数不会超过 maximumPoolSize，若是此时线程数超过了 maximumPoolSize，那么执行拒绝策略。
三、任务执行过程当中发生异常怎么处理？
若是某个任务执行出现异常，那么执行任务的线程会被关闭，而不是继续接收其余任务。而后会启动一个新的线程来代替它。
四、何时会执行拒绝策略？
- workers 的数量达到了 corePoolSize，任务入队成功，以此同时线程池被关闭了，并且关闭线程池并无将这个任务出队，那么执行拒绝策略。这里说的是很是边界的问题，入队和关闭线程池并发执行，读者仔细看看 execute 方法是怎么进到第一个 reject(command) 里面的。
- workers 的数量大于等于 corePoolSize，准备入队，但是队列满了，任务入队失败，那么准备开启新的线程，但是线程数已经达到 maximumPoolSize，那么执行拒绝策略。
6、参考资料
书籍：《码出高效：Java开发手册》
Java核心技术36讲：http://t.cn/EwUJvWA
深度解读 java 线程池设计思想及源码实现：https://javadoop.com/post/java-thread-pool
Java线程池-ThreadPoolExecutor源码解析(基于Java8)：https://www.imooc.com/article/42990
课程推荐：
相关文章
- 1. Java核心（二）深刻理解线程池ThreadPool
- 2. Java核心（二）深入理解线程池ThreadPool
- 3. Java线程池（ThreadPool）详解
- 4. 深刻理解线程Java线程池系列二之ForkJoinPool
- 5. 深刻理解Java线程池
- 6. 深刻理解Java线程池：ThreadPoolExecutor
- 7. 深刻理解java之线程池
- 8. 深刻理解Java线程池：ScheduledThreadPoolExecutor
- 9. 深刻理解 Java 线程池
- 10. 深刻理解Java之线程池
- 更多相关文章...
- • C# 多线程 - C#教程
- • SQLite - Java - SQLite教程
- • Java 8 Stream 教程
- • IDEA下SpringBoot工程配置文件没有提示
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
