一、线程池简介

1、池化思维

在我的项目工程中，基于池化思维的技术利用很多，例如基于线程池的工作并发执行，中间件服务的连接池配置，通过对共享资源的治理，升高资源的占用耗费，晋升效率和服务性能。

池化思维从直观感觉上了解，既有作为容器的存储能力（持续性的承接），也要具备维持一定量的储备能力（初始化的提供），同时作为容器又必然有大小的限度，上面通过这个根底逻辑来详细分析Java中的线程池原理。

2、线程池

首先相熟JVM执行周期的都晓得，在内存中频繁的创立和销毁对象是很影响性能的，而线程作为过程中运行的根本单位，通过线程池的形式重复使用已创立的线程，在工作执行动作上防止或缩小线程的频繁创立动作。

线程池中保护多个线程，当收到调度工作时能够防止创立线程间接执行，并以此升高服务资源的耗费，把绝对不确定的并发工作治理在绝对确定的线程池中，进步零碎服务的稳定性。下文基于JDK1.8围绕ThreadPoolExecutor类深入分析。

二、原理与周期

1、类图设计

Executor 接口

源码正文解读：未来会执行命令，工作提交和执行两个动作会被解耦，传入Runnable工作对象即可，线程池会执行相应调度和工作解决。Executor尽管是ThreadPoolExecutor线程池的顶层接口，然而其自身只是形象了工作的解决思维。

ExecutorService 接口

扩大Executor接口，单个或批量的给工作的执行后果生成Future，并削减工作中断或终止的治理办法。

AbstractExecutorService 抽象类

提供对ExecutorService接口定义的工作执行办法（submit，invokeAll）等默认实现，提供newTaskFor办法用于构建RunnableFuture对象。

ThreadPoolExecutor 类

保护线程池生命周期，治理线程和工作，通过相应调度机制实现工作的并发执行。

2、根本案例

示例中创立了一个简略的butte-pool线程池，设置4个外围线程执行工作，队列容器设置256大小；在理论业务中，对于参数设定须要考量工作执行工夫，服务配置，测试数据等。

public class ThrPool implements Runnable {    private static final Logger logger = LoggerFactory.getLogger(ThrPool.class) ;    /**     * 线程池治理，ThreadFactoryBuilder出自Guava工具库     */    private static final ThreadPoolExecutor DEV_POOL;    static {        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("butte-pool-%d").build();        DEV_POOL = new ThreadPoolExecutor(0, 8,60L, TimeUnit.MILLISECONDS,                new LinkedBlockingQueue<>(256),threadFactory, new ThreadPoolExecutor.AbortPolicy());        DEV_POOL.allowCoreThreadTimeOut(true);    }    /**     * 工作办法     */    @Override    public void run() {        try {            logger.info("Print...Job...Run...；queue_size：{}",DEV_POOL.getQueue().size());            Thread.sleep(5000);        } catch (Exception e){            e.printStackTrace();        }    }}

通过对上述线程池外围参数的一直调整，以及管制工作执行工夫的长短，尤其能够设置一些参数的极其值，察看工作执行的成果，能够初步感知线程池的运行特点，上面围绕该案例开展具体的剖析。

3、构造方法

在ThreadPoolExecutor类中提供多个构造方法，以满足不同场景下线程池的结构需要，这里须要形容几个注意事项：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,                          BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory)

从构造方法的判断中，corePoolSize的大小容许设置为0，在剖析工作执行时再细说影响；
线程池创立后，不会立刻启动外围线程，通常会等到工作提交的时候再去启动；或者被动执行prestartCoreThread||prestartAllCoreThreads办法；
在以后版本的JDK中，CoreThread外围线程也是容许超时终止掉的，防止线程长时间闲置；
如果容许外围线程超时终止，该办法会校验keepAliveTime必须大于0，否则抛出异样；

4、运行原理

线程池的根本运行逻辑，工作提交之后有三种解决形式：间接调配线程执行；或者被放入工作队列，期待执行；如果间接被回绝，会返回异样；工作的提交和执行被解耦，形成一个生产生产的模型。

5、生命周期

这里从源码开始逐渐剖析线程池的外围逻辑，首先看看对于生命周期的状态形容，波及如下几个外围字段：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));private static final int COUNT_BITS = Integer.SIZE - 3;private static final int CAPACITY   = (1 << COUNT_BITS) - 1;// 状态形容private static final int RUNNING    = -1 << COUNT_BITS;private static final int SHUTDOWN   =  0 << COUNT_BITS;private static final int STOP       =  1 << COUNT_BITS;private static final int TIDYING    =  2 << COUNT_BITS;private static final int TERMINATED =  3 << COUNT_BITS;

ctl控制线程池的状态，蕴含两个概念字段：workerCount线程池内无效线程数，runState运行状态，具体的运行有5种状态形容：

RUNNING：承受新工作，解决阻塞队列中的工作；
SHUTDOWN：不承受新工作，解决阻塞队列中已存在的工作；
STOP：不承受新工作，不解决阻塞队列中的工作，中断正在进行的工作；
TIDYING：所有工作都已终止，workerCount=0，线程池进入该状态后会执行terminated()办法；
TERMINATED: 执行terminated()办法完后进入该状态；

状态之间的转换逻辑如下：

通过runStateOf()办法能够计算以后的运行状态，这里对于线程池生命周期的定义，以及状态的转换逻辑在ctl字段的源码正文中，更多细节能够参考该处形容文档。

三、工作治理

1、调度逻辑

从上面对线程池有整体的理解之后，当初从工作提交和执行这个外围流程动手，对源码和逻辑进行深入分析。任务调度作为线程池的外围能力，能够间接从execute(task)办法切入。

public void execute(Runnable command) {    // 上文形容的workerCount与runState    int c = ctl.get();    // 外围线程池    if (workerCountOf(c) < corePoolSize){}    // 工作队列    if (isRunning(c) && workQueue.offer(command)){}    // 回绝策略    else if (!addWorker(command, false)) reject(command);}

从整体上看，任务调度被放在三个分支步骤中判断，即：外围线程池、工作队列、回绝策略，上面再细看每个分支的解决逻辑；

1.1 外围线程池

// 如果无效线程数小于外围线程数，新建线程并绑定当前任务if (workerCountOf(c) < corePoolSize) {    if (addWorker(command, true))}

1.2 工作队列

// 如果线程池是运行状态，并且工作增加队列胜利if (isRunning(c) && workQueue.offer(command)) {    // 二次校验如果是非运行状态，则移除该工作，执行回绝策略    int recheck = ctl.get();    if (! isRunning(recheck) && remove(command))        reject(command);    // 如果无效线程数是0，执行addWorker增加办法    else if (workerCountOf(recheck) == 0)        addWorker(null, false);}

1.3 回绝策略

// 再次执行addWorker办法，如果失败则回绝该工作else if (!addWorker(command, false)) reject(command);

这样execute办法执行逻辑，任务调度的流程如下：

如上图工作被提交到线程池后的外围调度逻辑，工作既然提交天然是心愿被执行的，源码中也多处调用addWorker办法增加工作线程。

2、Worker线程

线程池内工作线程被封装在Worker类中，继承AQS并实现Runnable接口，保护线程的创立和工作的执行：

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {    final Thread thread; // 持有线程    Runnable firstTask;  // 初始化工作}

2.1 addWorker 办法

既然增加工作线程，象征有工作须要执行：

firstTask：新创建的线程第一个执行的工作，容许为空或者null；
core：传true，新增线程时判断以后线程数是否小于corePoolSize；传false，新增线程时判断以后线程数是否小于maximumPoolSize；

private final HashSet<Worker> workers = new HashSet<Worker>();private final BlockingQueue<Runnable> workQueue;private boolean addWorker(Runnable firstTask, boolean core) ；

通过对该办法的源码剖析，执行逻辑流程如下：

工作线程创立之后，在HashSet中保护和持有线程的援用，这样就能够对线程池做相应的put或者remove操作，进而对生命周期进行治理。

2.2 runWorker 办法

在Worker类中对于run办法的实现，实际上是委托给runWorker办法，用来周期性执行具体的线程工作，同样剖析其执行逻辑：

整个执行流程通过while循环不断获取工作并执行工作，整个过程也须要一直的校验线程池状态，及时的中断线程执行，该办法执行实现后会申请线程销毁动作。

3、工作队列

线程池两大外围能力线程和工作的治理，并且对二者解耦，通过队列中工作的治理构建生产生产模式，不同的队列类型有各自的存取政策；LinkedBlockingQueue创立链表构造的队列，默认的Integer.MAX_VALUE容量适度，须要指定队列大小，依照先进先出的准则治理；

3.1 getTask 办法

在获取工作时，除了必要的线程池状态判断，就是要校验当前任务的线程是否须要超时回收，下面曾经提过即便外围线程池也能够设置超时时效，如果没有获取到工作，则认为runWorker办法执行实现：

3.2 reject 办法

不论是线程池还是工作队列，都有容量的边界，当容量达到下限时，就须要回绝新提交的工作，在上述案例中采纳的是ThreadPoolExecutor.AbortPolicy抛弃工作并抛出异样，还有其余几种策略按需抉择即可。

四、监控与配置

在大部分的我的项目中，对于线程池都是间接定义好相干参数，如果须要调整，也根本都须要服务重启来实现，实际上线程池有一些放开的参数调整与查问的办法：

setCorePoolSize 办法

在办法外部通过一系列的逻辑校验，保障线程池安稳的过渡，整个流程谨严且简单，联合线程池参数获取办法，就能够进行动态化的参数配置与监控，从而实现可控的线程池治理：

最初对于更多线程池的细节问题，能够多浏览源码文档，并联合案例进行实际；线程池的原理在很多组件中都有利用，例如各种连接池，并行计算等，同样值得深刻学习和总结。

五、参考源码

利用仓库：https://gitee.com/cicadasmile/butte-flyer-parent组件封装：https://gitee.com/cicadasmile/butte-frame-parent