一、线程池简介

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