池塘里养：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