java线程池
一、线程池的好处
1、为什么需要使用线程池
- 反复创建线程开销大（内存和垃圾回收）
- 过多的线程会导致内存消耗
- 线程池可以规避上述问题，它可以复用每一个线程，并且还可以控制线程总量，便于管理
3、不使用线程池会怎么样
- 每次创建和销毁线程都需要资源的
开销，会有很大部分的资源浪费 - 任务数量过多时,新建线程过多可能会OOM异常，即内存溢出。
5、线程池的优点
- 加快响应速度
- 便于线程的管理控制，方便数据统计
- 限制线程资源的总量，合理利用CPU和内存
6、线程池适合的场合
- 服务器接受到大量请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率；
- 实际上，在开发中，如果需要创建5个以上的线程，那么就可以使用线程池来管理
二、创建和停止线程池
1、线程池构造函数的参数
| 参数 | 类型 | 含义 |
|---|---|---|
| corePoolSize | int | 核心线程数 |
| maxPoolSize | int | 最大线程数 |
| keepAliveTime | long | 保持存活时间 |
| workQueue | BlockingQueue |
任务存储队列 |
| threadFactory | ThreadFactory | 当线程池需要新的线程的时候，会使用threadFactory来生成新的线程 |
| Handler | RejectedExecutionHandler | 由于线程池无法接受你所提交的任务的拒绝策略 |
（1）corePoolSize
核心线程池大小， 线程池初始化后，默认是没有任何线程的，当新的任务到线程池后，线程池会创建新的线程（即使有空闲线程），直到核心线程池已满。
(2) maxPoolSize：
最大线程池大小，顾名思义，线程池能创建的线程的最大数目.
什么情况下线程数量会超过 corePoolSize ，增加到 maxPoolSize ？
-
新任务到来时，如果线程数小于corePoolSize ，即使其他工作线程处于空闲状态，也会创建一个新线程来运行新任务；
-
如果线程数等于或大于corePoolSize 但是少于maxPoolSize，则将任务放入workQueue队列（指定队列的容量）；
-
如果队列已满，并且线程数小于maxPoolSize，则创建一个新线程来运行任务；
-
如果队列已满，并在线程数等于或大于maxPoolSize，则执行Handler拒绝策略；
总之，是否需要增加线程的判断顺序是：corePoolSize -》workQueue-》maxPoolSize
线程池的线程数量增减的特点
- 通过corePoolSize 和maxPoolSize相同，就可以创建固定大小的线程池；
- 线程池希望保持较少的线程数，并且只有在负载变得很大的时候才增加它；
- 通过设置maxPoolSize为很高的值，可以允许线程池容纳任意数量的并发任务；
- 只有在队列填满时才多于corePoolSize 的线程，所以如果你使用的是无界队列，那么线程数就不会超过corePoolSize ；
（3）keepAliveTime：
如果线程池当前的线程数多于corePoolSize ，其中多余的那部分线程空闲时间超过keepAliveTime，它们就会被终止，比如：corePoolSize 为5，当前线程数为10，如果线程空闲了，就会恢复到5；
(4) ThreadFactory：
用来创建线程，默认是非守护线程，优先级是5，一共有10个等级；
(5) workQueue：
一个阻塞队列，用来存储等待执行的任务，有3种最常见的队列类型：
- 直接交接：SynchronousQueue，一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法
Executors.newCachedThreadPool使用了这个队列。 - 无界队列：LinkedBlockingQueue，一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法
Executors.newFixedThreadPool()使用了这个队列。队列的容量没有上限，有可能造成OOM。 - 有界队列：ArrayBlockingQueue，是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
(6) RejectedExecutionHandler
当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。有下面四种JDK提供的策略：
- AbortPolicy，表示无法处理新任务时抛出异常, 默认策略
- CallerRunsPolicy：用调用者所在线程来运行任务，即谁给的任务谁来执行
- DiscardOldestPolicy： 该策略将丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。
- DiscardPolicy：不处理，丢弃掉
除了这些JDK提供的策略外，还可以自己实现 RejectedExecutionHandler 接口定义策略。
2、线程池创建
Excutors类提供的创建线程池的方法如下：
(1) newFixedThreadPool
创建固定大小的线程池，核心线程数和最大线程数相等。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
- 源码：
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
- 使用演示：
/**
* 演示newFixedThreadPool
*/
public class FixedThreadPoolTest {
//主函数
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(4);
//执行线程池
for (int i = 0; i < 1000; i++) {
threadPool.execute(new Task());
}
}
//任务类
static class Task implements Runnable {
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
打印结果：
发现提交1000个任务，却只有4个线程在执行任务，跟我们设定4个线程执行要求是一致的
- 错误演示
当因为任务过多无法处理导致内存资源耗尽
/**
* 演示newFixedThreadPool出错的情况
*/
public class FixedThreadPoolOOM {
//线程池
private static ExecutorService executorService = Executors.newFixedThreadPool(1);
public static void main(String[] args) {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
//执行任务
executorService.execute(new SubThread());
}
}
}
//任务类
class SubThread implements Runnable{
@Override
public void run() {
try {
Thread.sleep(1000000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
为了更块地看到内存溢出，我们可以主动设置jvm参数，如下
最后出现了内存溢出OOM
由于使用的 LinkedBlockingQueue是没有容量上限的，所以当请求数越来越多，并且无法及时处理完毕的时候，也就是请求堆积的时候，会容易造成占用大量的内存，可能会导致OOM。
(2) newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。
- 源码
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}
从源码可以看出，这里和刚才的newFixedThreadPool的原理基本一样，只不过把线程数直接设置成了1，所以这也会导致同样的问题，也就是当请求堆积的时候，可能会占用大量的内存。
- 使用演示
public class SingleThreadExecutor {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 1000; i++) {
executorService.execute(new Task());
}
}
}
class Task implements Runnable{
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
打印结果如下，始终只有一个线程名字，说明只有一个线程：
(3) newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小, 极端情况下会因为创建过多线程而耗尽系统资源，引发OOM
- 特点：一个采用SynchronousQueue的
无界限线程池，具有60s自动回收多余线程的功能 - 源码：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
- 使用演示
public class CachedThreadPool {
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 1000; i++) {
pool.execute(new Task());
}
}
static class Task implements Runnable{
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
打印结果
可以看到，每一个新任务，都会创建一个线程，他创建了1000个线程
（4）newScheduledThreadPool
- 主要用来在给定的延迟之后运行任务，或者定期执行任务。
- 源码
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
- 使用演示
public class ScheduleThreadPool {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
//5秒钟执行任务，不重复执行
// pool.schedule(new Task(),5, TimeUnit.SECONDS);
//一开始1后执行任务，后面每隔3秒执行
pool.scheduleAtFixedRate(new Task(),1,3,TimeUnit.SECONDS);
}
}
打印结果：
由于设置了 corePoolSize=10,所以会出现10个线程，这10个线程执行的是同一个任务：一开始1s后执行任务，后面每隔3秒执行一次
（5）newWorkStealingPool
newWorkStealingPool 是jdk1.8才有的，会根据所需的并行层次来动态创建和关闭线程，通过使用多个队列减少竞争，底层用的 ForkJoinPool来实现的。ForkJoinPool 的优势在于，可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。
五种线程池的使用场景
- newSingleThreadExecutor：一个单线程的线程池，可以用于需要保证顺序执行的场景，并且只有一个线程在执行。
- newFixedThreadPool：一个固定大小的线程池，可以用于已知并发压力的情况下，对线程数做限制。
- newCachedThreadPool：一个可以无限扩大的线程池，比较适合处理执行时间比较小的任务。
- newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。
- newWorkStealingPool：一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。
以上都是使用 Executors 提供的方法创建线程池，不过更建议直接使用
ThreadPoolExecutor创建线程池,这样我们就能根据不同的业务场景，自己设置线程池参数，比如我们的内存有多大，我们想给线程取什么名字等等
3、线程池设定线程数量如何选择？
- CPU密集型：比如八核处理器，那可以把corePoolSize 设置为核心数的1-2倍；
- 耗时IO型（读写文件）：这种类型的CPU是不工作的，可以设置为核心数的很多倍
- 线程数=CPU核心数*（1+平均等待时间/平均工作时间）
4、停止线程的正确方法
(1) shutdown:
初始化整个关闭过程，不是直接关闭，把正在执行以及队列中等待的任务执行完毕再关闭，然后拒绝新的任务；
使用演示：
public class StopThreadPool {
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
for (int i = 0; i < 50; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println("执行已经提交的线程:" +Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
Thread.sleep(1000);
executorService.shutdown();
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("继续提交线程池");
}
});
}
}
打印结果：
可以看出，shutdown后，再次提交是被拒绝的，抛出异常：RejectedExecutionException，但是已经提交的任务会慢慢执行完毕。
(2) isShutdown、isTerminated、awaitTermnation、shutdownNow
- isShutdown：判断是否被shutdown了；
- isTerminated：判断线程池是否完全终止；
- awaitTermnation：检测一段时间后线程池是否完全终止，是用来检测的；
- shutdownNow：立刻停止线程池，立刻停止的过程：利用线程InterruptedException中断抛出异常停止线程，同时该方法会返回一个集合，包含已经放进队列中还没来得急执行的线程对象；
//演示关闭线程池
public class ShutdownPool {
public static void main(String[] args) throws InterruptedException {
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
pool.execute(new ShutdownTask());
}
Thread.sleep(1500);
pool.shutdownNow();
boolean flag = pool.awaitTermination(3, TimeUnit.SECONDS);
System.out.println(flag);
System.out.println(pool.isShutdown());
Thread.sleep(10000);
System.out.println(pool.isTerminated());
//再次执行任务
pool.execute(new ShutdownTask());
}
}
class ShutdownTask implements Runnable{
@Override
public void run() {
try {
Thread.sleep(500);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName()+": 被中断了");
}
}
}
打印结果：
三、常见线程池的特点和用法
| 线程池创建方法 | corePoolSize | maxPoolSize | keepAliveTime | workQueue |
|---|---|---|---|---|
| newFixedThreadPool | 指定 | 等于maxPoolSize | 0s | LinkedBlockingQueue |
| newSingleThreadExecutor | 1 | 1 | 0s | LinkedBlockingQueue |
| newCachedThreadPool | 0 | Integer.MAX_VALUE | 60s | SynchronousQueue |
| newScheduledThreadPool | 指定 | Integer.MAX_VALUE | 0s | DelayedWorkQueue |
四、任务太多，怎么拒绝？
1、拒绝时机
出现以下其中一种情况时，会拒绝：
- 一旦线程池shutDown，后续的任务就被拒绝了；
- 当Executor对最大线程maxPoolSize 和工作队列容量使用ArrayBlockingQueue有限边界并饱和时候，就直接拒绝了；
2、拒绝策略
- AbortPolicy，抛出异常；
- DiscardPolicy，默默抛弃，不抛出异常；
- DiscardOldestPolicy，丢弃最老的，存在时间最久的任务给丢掉；
- CallerRunsPolicy，如果线程池没办法处理，谁提交的任务谁去跑，比如主线程提交的任务，那么线程池饱和的情况下，就交还给主线程执行这个任务；
3、钩子方法
每个任务执行前后，可以放置钩子方法，来做一些事情，比如日志、统计等；
//演示任务前后，可有钩子桉树
public class PauseableThreadPool extends ThreadPoolExecutor {
private boolean isPaused;//标记位
private final ReentrantLock lock = new ReentrantLock();//锁
private final Condition unpaused = lock.newCondition();//类似wait/notify...
//主函数
public static void main(String[] args) throws InterruptedException {
PauseableThreadPool pool = new PauseableThreadPool(10, 20, 10L, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("我被执行");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
for (int i = 0; i < 10000; i++) {
pool.execute(task);
}
Thread.sleep(1500);
pool.pause();
System.out.println("线程池被暂停了。。。。。。。。。。");
Thread.sleep(1500);
pool.resume();
System.out.println("线程池恢复了。。。。。。。。。。。。");
}
//钩子函数，任务执行前
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
lock.lock();
try {
while (isPaused) {
//暂停线程
unpaused.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
//暂停
private void pause() {
lock.lock();
try {
isPaused = true;
} finally {
lock.unlock();
}
}
//恢复
private void resume() {
lock.lock();
try {
isPaused = false;
//唤醒线程
unpaused.signalAll();
} finally {
lock.unlock();
}
}
//下面↓↓↓ 是继承 ThreadPoolExecutor 默认实现的，不用管
public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
}
public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
}
public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
}
打印结果：
五、线程池实现原理
1、线程池组成部分
- 线程池管理器
- 工作线程
- 任务队列
- 任务接口（Task）
2、Executor家族
-
Executor：接口，ExecutorService继承于Executor ；
-
Executors：工具类，帮我们自动创建线程池，类似于Collections；
-
ThreadPoolExecutor：线程池类，ThreadPoolExecutor继承于ExecutorService；
所以，Executor、ExecutorService、ThreadPoolExecutor都是线程池类型，只不过是继承关系；
3、线程池实现任务复用
相同线程执行不同任务，调用新的任务的run方法，在while中不停的循环执行
// 源码
final void runWorker(Worker w) {
Runnable task = w.firstTask;
while (task != null || (task = getTask()) != null) {
task.run();
}
}
在runWork中，拿到一个又一个的task，while循环中判断如果不为空，则执行完毕task的run方法，如果task为空，即执行完毕了一个任务，则用getTask方法去取下一个任务，直到没有任务了。
4. execute()方法的源码
线程池的运行原理图：
结合上面的线程池运行原理图和下面的execute() 方法源码，梳理一下线程池的执行过程：
public void execute(Runnable command) {
//判断提交的任务是否为 null, 是则抛出异常,commond:指接下来要执行的任务
if (command == null)
throw new NullPointerException();
/*
* 获取线程池控制状态
* ctl 是一个 AtomicInteger 变量 （骚操作）
* jdk 8 中通过一个 int 值的前 28 位表示工作线程数量 workerCount, 剩余高位来表示 线程池状态
* 计算 workerCount 和 runState 时通过掩码计算。 CAPACITY = (1 << 29) - 1
* private static int runStateOf(int c) { return c & ~CAPACITY; }
* private static int workerCountOf(int c) { return c & CAPACITY; }
* */
int c = ctl.get();
//1. 当线程数小于 核心线程池容量时 将添加工作线程去执行任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true)) // 这里的 core 为 true,表示当前线程数小于核心线程数，添加的线程在 核心线程数范围内，为false就是超过核心线程数，但是在最大线程数范围内
return;
c = ctl.get(); // 不成功则再次获取线程池控制状态
}
//2. （worker线程数量大于核心线程池容量时）如果线程池处于 RUNNING 状态，将命令加入 workQueue 队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get(); //再次检查防止状态突变
if (! isRunning(recheck) && remove(command))
//2.1 如果状态改变，线程池没有 RUNNING 则将命令移出队列，并拒绝执行
reject(command);
else if (workerCountOf(recheck) == 0)
//2.2 状态没有改变，线程池 RUNNING，但 worker线程数量为 0， 则添加非core的worker线程
addWorker(null, false);
}
//3. 如果线程池没有 RUNNING 并尝试添加非core的 worker 线程失败，那就拒绝执行
else if (!addWorker(command, false))
reject(command);
}
- 如果运行的线程小于 corePoolSize，则尝试使用用户定义的 Runnalbe 对象创建一个新的线程。调用 addWorker() 函数会原子性的检查runState 和 workCount，通过返回 false 来防止在不应该添加线程时添加了线程
- 如果一个任务能够成功入队列，在添加一个线程时仍需要进行双重检查（可能因为在前一次检查后该线程死亡了），或者当进入到此方法时，线程池已经shutdown了，所以需要再次检查状态。若线程此时的状态不是 RUNNING，则需要回滚入队列操作；或者当线程池没有工作线程时，需要创建一个新的工作线程。
- 如果无法入队列，那么需要增加一个新工作线程，如果此操作失败，那么就意味着线程池已经 SHUTDOWN 或者已经饱和了，所以拒绝任务
addWorker()方法的源码
此方法用来创建新的线程添加到线程池
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/*
* 检查线程池状况， 确保此时可以添加新的线程，
* 如果是runing，那么跳过if。
* 如果rs>=SHUTDOWN,同时不等于SHUTDOWN，即为SHUTDOWN以上的状态，那么不接受新线程。
* 如果rs>=SHUTDOWN，同时等于SHUTDOWN，同时first != null，那么拒绝新线程，
* 如果为Empty，那么队列已空，不需要增加消耗线程，返回 false。
* */
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
/*
* 判断线程池是否已满，如果线程数大于等于最大容量 CAPACITY 直接返回false
* core 是一个boolean 参数，表明调用者想把此线程添加到哪个线程池
* 根据 core 的值判断要添加的线程池是否已满
**/
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//CAS 操作增加工作线程数
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//CAS 操作失败， 再次检查状态重来一次
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 {
// 再次检查状态，因为状态可能在获取锁之前改变
int rs = runStateOf(ctl.get());
//确保当前线程池还接收新的线程
//结合上面的线程状态知道：当状态值大于等于 SHUTDOWN 时 线程池就不再接收新的线程了
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;
}
从上面两段源码可以看到， 在添加新的线程进入线程池时，各种操作非常的严谨细致，往往需要多次检查状态，确保线程池的正确运行。
worker工作线程的源码
线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。我们可以从Worker的runWorker方法里看到：
final void runWorker(Worker w) {
// 获取当前线程
Thread wt = Thread.currentThread();
// 获取w的firstTask
Runnable task = w.firstTask;
// 设置w的firstTask为null
w.firstTask = null;
// 释放锁（设置state为0，允许中断）
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) { // 任务不为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;
// 增加给worker完成的任务数量
w.completedTasks++;
// 释放锁
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 处理完成后，调用钩子函数
processWorkerExit(w, completedAbruptly);
}
}
5. 线程池的状态
- RUNNING：接收新任务并处理排队任务，即执行execute后的状态；
- SHUTDOWN：不接受新任务，但是处理排队任务，即执行shutdown方法后的状态；
- STOP：不接受新任务，也不处理排队的任务，并中断正在进行的任务，即执行
shutdownNow方法后的状态； - TIDYING：整洁，所有任务都已经终止，线程会转到TIDYING状态，并将运行 terminated() 方法；
- TERMINATED：终止状态, terminated()方法完成；
状态转换图：
六、使用线程池的注意点
- 避免任务堆积
- 避免线程数过度增加
- 排查线程泄漏：指线程执行完任务不能被回收，一般都是任务的逻辑出现问题，任务无法真正结束，现成也就无法被回收
