HikariDataSource核心源码分析

一、前言

上一篇文章讲了不合理的连接池代码导致的内存泄露事件，详见这篇文章记一次多数据源路由造成的数据库连接泄露排查过程。其中粗略的分析了HikariDataSource连接池的代码，并没有仔细分析。本篇文章带读者们一起去分析一波源码，看完本篇文章后，你可以
1、对锁和高并发有一定理解以及其在连接池中的运用
2、了解HikariDataSource业界性能最高连接池的原因
3、可以对连接池的原理有大致的了解，可以尝试自己实现一个连接池

二、源码分析

2.0 关键代码类介绍

1. HikariDataSource对象：Hikari中的核心类为HikariDataSource，实现了DataSource的getConnetion接口
2. HikariPool对象：HikariDataSource中有两个HikariPool对象,一个是fastPathPool是在HikariPool有参构造函数中创建, 如果没有创建fastPathPool,那么就会在getConnection方法时创建pool对象。
3. ConcurrentBag对象：连接池的真正实现，实现了高性能高并发的无锁设计，主要的方法有borrow 借,requite 归还,add 新增,remove 去除。
4. PoolEntry对象：对数据库connection对象进行包装，增加额外的属性，包括最后一次访问时间，是否丢弃，当前状态等等。HikariDataSource源码底层里面都是操作这个对象。

2.1 初始化（以下所有代码只列出关键实现）

初始化工作包括HikariDataSource初始化，HikariPool初始化，connectionBag初始化，一些线程池的初始化，最小连接数的初始化，以下逐一分析

public HikariDataSource(HikariConfig configuration)
{
  // 一个datasource有两个HikariPool成员变量，fastPathPool无参构造为null，用final修饰，pool有参构造，用volatile修饰
  // 因为volatile修饰的对象，需要从主内存读取，而且需要写入主内存等操作，所以最好在使用上用有参构造来构造HikariDataSource
  pool = fastPathPool = new HikariPool(this);
  // 连接池配置锁定无法修改
  this.seal();
}
// HikariPool初始化成员变量EntryCreator，创建PoolEntry的任务
private final PoolEntryCreator postFillPoolEntryCreator = new PoolEntryCreator("After adding ");

public HikariPool(final HikariConfig config)
{
  // 初始化配置，根据配置生成datasource变量
  super(config);
  // 生成真正的连接池，后续的获取连接释放连接都是从这里面弄的
  this.connectionBag = new ConcurrentBag<>(this);
  // 测试数据库的连通性
  checkFailFast();
  // 增加连接的线程池
  this.addConnectionExecutor = createThreadPoolExecutor(addConnectionQueue, poolName + " connection adder", threadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());
  // 关闭连接的线程池
  this.closeConnectionExecutor = createThreadPoolExecutor(maxPoolSize, poolName + " connection closer", threadFactory, new ThreadPoolExecutor.CallerRunsPolicy());
  // 初始化维持最小连接数任务
  this.houseKeeperTask = houseKeepingExecutorService.scheduleWithFixedDelay(new HouseKeeper(), 100L, housekeepingPeriodMs, MILLISECONDS);
}

重点是维持最小连接数任务，如下：

private final class HouseKeeper implements Runnable{
  public void run(){
     // Detect retrograde time, allowing +128ms as per NTP spec.
    if (plusMillis(now, 128) < plusMillis(previous, housekeepingPeriodMs)) {
       previous = now;
       // 标为丢弃的连接关闭
       softEvictConnections();
       return;
    }
    if (idleTimeout > 0L && config.getMinimumIdle() < config.getMaximumPoolSize()) {
       // 获取当前连接池中已经不是使用中的连接集合
       final List<PoolEntry> notInUse = connectionBag.values(STATE_NOT_IN_USE);
       int toRemove = notInUse.size() - config.getMinimumIdle();
       for (PoolEntry entry : notInUse) {
          // 如果PoolEntry的最后一次访问的时间超过了idleTimeout并且将这个PoolEntry的状态变为不可借状态STATE_RESERVED
          // STATE_RESERVED状态底层变更是CAS变更，用到的类是AtomicIntegerFieldUpdater，可以对指定类的指定 volatile int 字段进行原子更新
          if (toRemove > 0 && elapsedMillis(entry.lastAccessed, now) > idleTimeout && connectionBag.reserve(entry)) {
             // 关闭连接
             closeConnection(entry, "(connection has passed idleTimeout)");
             toRemove--;
          }
       }
    }
    // 填充最小连接到minimum。 在初始化时候就填充连接，异步填充
    fillPool();
  }
}
// 填充连接
// 当没有达到最大连接数之前 或者 空闲连接数小于最小连接数时候 就异步提交创建poolEntryCreator任务
private synchronized void fillPool(){
  final int connectionsToAdd = Math.min(config.getMaximumPoolSize() - getTotalConnections(), config.getMinimumIdle() - getIdleConnections())
                               - addConnectionQueueReadOnlyView.size();
  for (int i = 0; i < connectionsToAdd; i++) {
     addConnectionExecutor.submit((i < connectionsToAdd - 1) ? poolEntryCreator : postFillPoolEntryCreator);
  }
}

// 关闭连接
void closeConnection(final PoolEntry poolEntry, final String closureReason){
    // 如果remove成功，将状态设置为STATE_REMOVED
	if (connectionBag.remove(poolEntry)) {
     final Connection connection = poolEntry.close();
     // 异步关闭
     closeConnectionExecutor.execute(() -> {
        quietlyCloseConnection(connection, closureReason);
        if (poolState == POOL_NORMAL) {
           fillPool();
        }
     });
  }
}

以上大致逻辑就是，将被标为丢弃的连接关闭，将空闲超时的连接进行关闭，然后进行进连接填充连接，填充连接的逻辑就是增加poolEntryCreator任务,poolEntryCreator逻辑在后面分析。

2.2 获取连接

获取连接是主要的实现逻辑，首先看HikariDataSource对象getConnnection方法

// 双重锁实现
public Connection getConnection(){
	HikariPool result = pool;
	if (result == null) {
	 synchronized (this) {
	    result = pool;
	    if (result == null) {
	       pool = result = new HikariPool(this);
	       // 锁定配置，不能热更新配置
	       this.seal();
	    }
	 }
	}
	return result.getConnection();
}

result.getConnection()就是HikariPool getConnection方法，这里面大致核心逻辑就是加锁在超时时间内获取poolEntry的connectionBag.borrow方法，重点着重borrow方法实现。

在讲之前，先介绍以下connectionBag的几个重要的成员变量

1. final CopyOnWriteArrayList sharedList：当前所有缓存的poolEntry连接，都在这个list内，CopyOnWriteArrayList写时复制，在读多写少的场景下性能更高，一般情况下连接池中的poolEntry连接不会增加或者关闭，读场景多。
2. final ThreadLocal<List