线程池五种状态
线程池具有以下五种状态，当创建一个线程池时初始化状态为RUNNING
| RUNNING | 允许提交并处理任务 |
| SHUTDOWN | 不允许提交新的任务，但是会处理完已提交的任务 |
| STOP | 不允许提交新的任务，也不会处理阻塞队列中未执行的任务，并设置正在执行的线程的中断标志位 |
| TIDYING | 所有任务执行完毕，池中工作的线程数为0，等待执行terminated()勾子方法 |
| TERMINATED | terminated()勾子方法执行完毕 |
注意，这里说的是线程池的状态而不是池中线程的状态。
调用线程池的shutdown()，将线程池由RUNNING（运行状态）转换为SHUTDOWN状态。
调用线程池的shutdownNow()，将线程池由RUNNING或SHUTDOWN状态转换为STOP状态。
SHUTDOWN状态和STOP状态先会转变为TIDYING状态，最终都会变为TERMINATED.
方法声明
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) -
- 参数说明
| 参数 | 说明 |
| corePoolSize | 线程池中活跃的线程数量 |
| maximumPoolSize | 线程池中最大线程数量 |
| keepAliveTime | 超过corePoolSize个多余线程的存活时间 |
| unit | keepAliveTime的时间单位 |
| workQueue | 任务队列，被提交但尚未被执行的任务 |
| threadFactory | 线程工厂，用于创建线程 |
| handler拒绝策略 | 当任务太多来不及处理时，如何拒绝任务 |
例如：okhttp线程池
new ThreadPoolExecutor( 0, Integer.MAX_VALUE,
60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),Util.threadFactory("OkHttp Dispat cher", false)
); 该框架的线程池采用java中标准的可缓存线程池，让人阅读第三方框架越感觉基础知识重要。
再如：glide（GlideExecutor）中的线程池创建
new ThreadPoolExecutor(
threadCount /* corePoolSize */,
threadCount /* maximumPoolSize */,
0 /* keepAliveTime */,
TimeUnit.MILLISECONDS,
new PriorityBlockingQueue<Runnable>(),
new DefaultThreadFactory(name, uncaughtThrowableStrategy, false)));
当一个任务执行execute(Runnable)欲添加到线程池时 会有以下四种情况， ：
l 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
2 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列，等待任务调度执行。
3 如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池是大小固定的，如果运行的线程与corePoolSize相同，当有新请求过来时，若workQueue任务阻塞队列未满，则将请求放入workQueue中，等待有空闲的线程从workQueue中取出任务并处理；若任务阻塞队列已经，采用拒绝方式。
4 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的线程数量小于maximumPoolSize，建新的线程来处理被添加的任务； 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。
也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
corePoolSize：在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者 prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建 corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到阻塞队列当中；
maximumPoolSize ：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
上述规则参考下图：
图一
图二
原理
/**
* 1,corePoolSize：指定线程池中活跃的线程数量
* 2,maximumPoolSize：指定线程池中最大线程数量
* 3,keepAliveTime：超过corePoolSize个多余线程的存活时间
* 4,unit：keepAliveTime的时间单位
* 5,workQueue：任务队列，被提交但尚未被执行的任务
* 6,threadFactory：线程工厂，用于创建线程
* 7,handler拒绝策略：当任务太多来不及处理时，如何拒绝任务
*/
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;
}
workQueue
当任务被提交但尚未被执行的任务队列，是一个BlockingQueue接口的对象，只存放Runnable对象。根据队列功能分类，看下JDK提供的几种BlockingQueue
BlockingQueue分类说明
| work queue class name | 说明 |
| SynchronousQueue | 直接提交队列：没有容量，每一个插入操作都要等待一个相应的删除操作。通常使用需要将maximumPoolSize的值设置很大，否则很容易触发拒绝策略。 |
| ArrayBlockingQueue | 有界的任务队列：任务大小通过入参 int capacity决定，当填满队列后,才会创建大于corePoolSize的线程。 |
| LinkedBlockingQueue | 无界的任务队列：线程个数最大为corePoolSize，如果任务过多，则不断扩充队列，直到内存资源耗尽。 |
| PriorityBlockingQueue | 优先任务队列：是一个无界的特殊队列，可以控制任务执行的先后顺序，而上边几个都是先进先出的策略。 |
(1). 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
(2). 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize（因此，maximumPoolSize 的值也就无效了）。当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;
(3). 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。
拒绝策略
如果线程池处理速度达不到任务的出现速度时，只能执行拒绝策略，看下JDK提供几种，然后自定义看个例子
JDK提供的线程池拒绝策略
| 策略名称 | 描述 |
| AbortPolicy | 该策略会直接抛出异常，阻止系统正常 工作。线程池默认为此。 |
| CallerRunsPolicy | 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。 |
| DiscardOledestPolicy | 该策略将丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试重新提交当前任务。 |
| DiscardPolicy | 该策略默默地丢弃无法处理的任务，不予任务处理。 |
添加一个任务的流程
/**
* 三步：1，创建线程直到corePoolSize；2，加入任务队列；3，如果还是执行不过来，则执行拒绝策略
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
* 如果正在运行的线程少于corePoolSize，请尝试使用给定的命令启动一个新线程作为
其第一个任务。对addWorker的调用原子地检查runState和workerCount，
因此通过返回false，防止错误警报在不应该添加线程时添加线程。
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
* 如果任务可以成功排队，那么我们仍然需要反复检查是否应该添加线程(因为自上次检查以来已
有线程死亡)，还是在进入此方法后池关闭。因此，我们重新检查状态，如果有必要，如果停止，
回滚队列；如果没有，则启动一个新线程。
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
如果不能对任务进行队列处理，则尝试添加一个新线程。如果失败，我们知道我们已经关闭或饱和，
因此拒绝这项任务。
*/
int c = ctl.get();
// 1
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//2
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);
}
//3
else if (!addWorker(command, false))
reject(command);
}
核心模块用红框标记了。
- //1：workerCountOf方法根据ctl的低29位，得到线程池的当前线程数，如果线程数小于corePoolSize，则执行addWorker方法创建新的线程执行任务;
- // 2：判断线程池是否在运行，如果在，任务队列是否允许插入，插入成功再次验证线程池是否运行，如果不在运行，移除插入的任务，然后抛出拒绝策略。如果在运行，没有线程了，就启用一个线程。
- // 3：如果添加非核心线程失败，就直接拒绝了。
这里逻辑稍微有点复杂，画了个流程图仅供参考
接下来，我们看看如何添加一个工作线程的?
添加worker线程
从方法execute的实现可以看出：addWorker主要负责创建新的线程并执行任务，代码如下(这里代码有点长，没关系，也是分块的，总共有5个关键的代码块)：
- 第一个红框：做是否能够添加工作线程条件过滤：
判断线程池的状态，如果线程池的状态值大于或等SHUTDOWN，则不处理提交的任务，直接返回;
- 第二个红框：做自旋，更新创建线程数量：
通过参数core判断当前需要创建的线程是否为核心线程，如果core为true，且当前线程数小于corePoolSize，则跳出循环，开始创建新的线程
接着看后面的代码：
- 第一个红框：获取线程池主锁。
线程池的工作线程通过Woker类实现，通过ReentrantLock锁保证线程安全。
- 第二个红框：添加线程到workers中(线程池中)。
- 第三个红框：启动新建的线程。
接下来，我们看看workers是什么。
一个hashSet。所以，线程池底层的存储结构其实就是一个HashSet。
worker线程处理队列任务
- 第一个红框：是否是第一次执行任务，或者从队列中可以获取到任务。
- 第二个红框：获取到任务后，执行任务开始前操作钩子。
- 第三个红框：执行任务。
- 第四个红框：执行任务后钩子。
这两个钩子(beforeExecute，afterExecute)允许我们自己继承线程池，做任务执行前后处理。
Executors提供四种线程池，分别为：
可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程，源码如下：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}可以看出创建了一个核心线程数为0，最大线程数为一个Integer能表示的最大值，存活时间为60秒。队列为SynchronousQueue直接队列。这种情况下每来一个任务就创建一个线程执行。直到创建的线程数大于Integer.MAX_VALUE当然一般情况下不会出现。每一个线程的存货时间是60秒超过60秒后自动销毁。
定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。源码如下：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}可以看出创建了一个核心线程数为传入的nThreads，最大线程数也为nThreads，存活时间为0秒。队列为LinkedBlockingQueue即不保存队列任务。这种情况下每来一个任务首先看线程池数量有没有到nThreads，如果没有达到则创建一个新的线程并执行，否则加入队列中，等待执行。此处LinkedBlockingQueue没有指定大小即最多可以接收Integer.MAX_VALUE个缓冲任务。相当于创建了nThreads个线程来执行队列中的任务
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}和上面的newFixedThreadPool类似，只不过这里只有一个线程，即使用一个线程执行任务队列中的任务。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
private void test() {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
fixedThreadPool.execute(new MyThread(i));
}
}
class MyThread implements Runnable {
private int index = 0;
MyThread(int index) {
this.index = index;
}
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 创建一个执行任务的服务
ExecutorService es = Executors.newFixedThreadPool(3);
try {
// 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
Future future1 = es.submit(task1);
// 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行
System.out.println("task1: " + future1.get());
参考
《java并发编程的艺术》
https://www.cnblogs.com/rinack/p/9888717.html 等
6570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
