池塘里养：Connection；

一、设计与原理

1、根底案例

HiKariCP作为SpringBoot2框架的默认连接池，号称是跑的最快的连接池，数据库连接池与之前两篇提到的线程池和对象池，从设计的原理上都是基于池化思维，只是在实现形式上有各自的特点；首先还是看HiKariCP用法的根底案例：

import com.zaxxer.hikari.HikariConfig;import com.zaxxer.hikari.HikariDataSource;import java.sql.Connection;import java.sql.ResultSet;import java.sql.Statement;public class ConPool {    private static HikariConfig buildConfig (){        HikariConfig hikariConfig = new HikariConfig() ;        // 根底配置        hikariConfig.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/junit_test?characterEncoding=utf8");        hikariConfig.setUsername("root");        hikariConfig.setPassword("123456");        // 连接池配置        hikariConfig.setPoolName("dev-hikari-pool");        hikariConfig.setMinimumIdle(4);        hikariConfig.setMaximumPoolSize(8);        hikariConfig.setIdleTimeout(600000L);        return hikariConfig ;    }    public static void main(String[] args) throws Exception {        // 构建数据源        HikariDataSource dataSource = new HikariDataSource(buildConfig()) ;        // 获取连贯        Connection connection = dataSource.getConnection() ;        // 申明SQL执行        Statement statement = connection.createStatement();        ResultSet resultSet = statement.executeQuery("SELECT count(1) num FROM jt_activity") ;        // 输入执行后果        if (resultSet.next()) {            System.out.println("query-count-result："+resultSet.getInt("num"));        }    }}

2、外围相干类

HikariDataSource类：会集数据源形容的相干信息，例如配置、连接池、连贯对象、状态治理等；
HikariConfig类：保护数据源的配置管理，以及参数校验，例如userName、passWord、minIdle、maxPoolSize等；
HikariPool类：提供对连接池与池中对象治理的外围能力，并实现池相干监控数据的查询方法；
ConcurrentBag类：摈弃了惯例池中采纳的阻塞队列作为容器的形式，自定义该并发容器来存储连贯对象；
PoolEntry类：拓展连贯对象的信息，例如状态、工夫等，不便容器中追踪这些实例化对象；

通过对连接池中几个外围类的剖析，也能直观地领会到该源码的设计原理，与上篇总结的对象池利用有殊途同归之妙，只是不同的组件不同的开发者在实现的时候，都具备各自的形象逻辑。

3、加载逻辑

通过配置信息去构建数据源形容，在构造方法中基于配置再去实例化连接池，在HikariPool的结构中，实例化ConcurrentBag容器对象；上面再从源码层面剖析实现细节。

二、容器剖析

1、容器构造

容器ConcurrentBag类提供PoolEntry类型的连贯对象存储，以及根本的元素治理能力，对象的状态形容；尽管被HikariPool对象池类所持有，然而理论的操作逻辑是在该类中；

1.1 根底属性

其中最为外围的是sharedList共享汇合、threadList线程级缓存、handoffQueue即时队列；

// 共享对象汇合，寄存数据库连贯private final CopyOnWriteArrayList<T> sharedList;// 缓存线程级连贯对象，会被优先应用，防止被争抢private final ThreadLocal<List<Object>> threadList;// 期待获取连贯的线程数private final AtomicInteger waiters;// 标记是否敞开private volatile boolean closed;// 即时解决连贯的队列，当有期待线程时，通过该队列将连贯调配给期待线程private final SynchronousQueue<T> handoffQueue;

1.2 状态形容

在ConcurrentBag类中的IConcurrentBagEntry外部接口，被PoolEntry类实现，该接口定义连贯对象的状态：

STATE_NOT_IN_USE：未应用，即闲置中；
STATE_IN_USE：应用中；
STATE_REMOVED：被废除；
STATE_RESERVED：保留态，中间状态，用于尝试驱赶连贯对象时；

2、包装对象

容器的根本能力是用来存储连贯对象的，而对象的治理则须要很多扩大的跟踪信息，以无效的实现各种场景下的辨认，此时就须要借助包装类的引入；

// 业务真正应用的连贯对象Connection connection;// 最近拜访工夫long lastAccessed;// 最近借出工夫long lastBorrowed;// 状态形容private volatile int state = 0;// 是否驱赶private volatile boolean evict;// 生命周期完结时的调度工作private volatile ScheduledFuture<?> endOfLife;// 连贯生成的Statement对象private final FastList<Statement> openStatements;// 池对象private final HikariPool hikariPool;

这里须要留神FastList类实现List接口，为HiKariCP组件自定义，相比ArrayList类，出于对性能的谋求，在元素的治理时，去掉诸多的范畴校验。

三、对象治理

基于连接池的惯例用法，来看看连贯对象具体是如何治理，比方被借出，被开释，被废除等，以及这些操作下对象的状态转换过程；

1、初始化

上文加载逻辑的形容中，曾经提到在构建数据源的时候，会依据配置实例化连接池，在初始化的时候，基于两个外围切入点来剖析源码：1.实例化多少连贯对象、2.连贯对象转换包装对象；

在连接池的结构中执行了checkFailFast办法，在该办法内执行MinIdle最小闲暇数的判断，如果大于0，则创立一个包装对象并放入容器中；

public HikariPool(final HikariConfig config) ;private void checkFailFast() {    final PoolEntry poolEntry = createPoolEntry();    if (config.getMinimumIdle() > 0) {        connectionBag.add(poolEntry);    }}

须要留神两个问题，创立的连贯包装对象，初始状态是0即闲置中；另外尽管案例中设置MinIdle=4的值，然而这里的判断大于0，也只在容器中事后放入一个闲暇对象；

2、借用对象

从池中获取连贯对象时，理论调用的是容器类中的borrow办法：

public Connection HikariPool.getConnection(final long hardTimeout) throws SQLException ;public T ConcurrentBag.borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException ;

在执行borrow办法时，波及如下几个外围步骤与逻辑：

public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException{    // 遍历本地线程缓存    final List<Object> list = threadList.get();    for (int i = list.size() - 1; i >= 0; i--) {       final Object entry = list.remove(i);       final T bagEntry = weakThreadLocals ? ((WeakReference<T>) entry).get() : (T) entry;       if (bagEntry != null && bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) { }    }    // 减少期待线程数    final int waiting = waiters.incrementAndGet();    try {        // 遍历Shared共享汇合        for (T bagEntry : sharedList) {           if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) { }        }        // 肯定工夫内轮询handoff队列        listener.addBagItem(waiting);        timeout = timeUnit.toNanos(timeout);        do {           final T bagEntry = handoffQueue.poll(timeout, NANOSECONDS);        }     } finally {        // 缩小期待线程数       waiters.decrementAndGet();    }}

首先反向遍历本地线程缓存，如果存在闲暇连贯，则返回该对象；如果没有则寻找共享汇合；
遍历Shared共享汇合前，会标记期待线程数加1，如果存在闲暇连贯则间接返回；
当Shared共享汇合中也没有闲暇连贯时，这时以后线程进行肯定工夫的handoffQueue队列轮询，可能会有资源的开释，也可能是新增加的资源；

留神这里在遍历汇合时，取出的对象都会对状态进行判断和更新，如果失去闲暇对象，会更新为IN_USE状态，而后返回；

3、开释对象

从池中开释连贯对象时，理论调用的是容器类中的requite办法：

void HikariPool.recycle(final PoolEntry poolEntry) ;public void ConcurrentBag.requite(final T bagEntry) ;

在开释连贯对象时，首先更新对象状态为闲暇，而后判断以后是否有期待的线程，在borrow办法中期待线程会进入肯定工夫的轮询，如果没有的话则把对象放入本地线程缓存中：

public void requite(final T bagEntry) {    // 更新状态    bagEntry.setState(STATE_NOT_IN_USE);    // 期待线程判断    for (int i = 0; waiters.get() > 0; i++) {        if (bagEntry.getState() != STATE_NOT_IN_USE || handoffQueue.offer(bagEntry)) { }    }    // 本地线程缓存    final List<Object> threadLocalList = threadList.get();    if (threadLocalList.size() < 50) {        threadLocalList.add(weakThreadLocals ? new WeakReference<>(bagEntry) : bagEntry);    }}

留神这里波及到连贯对象的状态从应用中转为NOT_IN_USE闲暇；borrow与requite作为连接池中两个外围办法，负责资源创立与回收；

最初本篇文章并没有站在HiKariCP组件的整体设计上构思，只是剖析连接池这冰山一角，只管只是局部源码，然而曾经足够彰显出作者对于性能的极致谋求，比方：本地线程缓存、自定义容器类型、FastList等；能被广泛采纳必然存在诸多撑持的理由。

四、参考源码

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