SpringBoot HikariCP配置项及源码解析

  public Connection getConnection(final long hardTimeout) throws SQLException
   {
      //这里是防止线程池处于暂停状态（通常不允许线程池可暂停）
      suspendResumeLock.acquire();
      final long startTime = currentTime();
      try {
         long timeout = hardTimeout;
         do {
            //PoolEntry 用于跟踪connection实例，里面包装了Connection;
            //从connectionBag中获取一个对象，并且检测是否可用
            PoolEntry poolEntry = connectionBag.borrow(timeout, MILLISECONDS);
            if (poolEntry == null) {
               break; // We timed out... break and throw exception
            }
            final long now = currentTime();
            //1、已被标记为驱逐 2、已超过最大存活时间 3、链接已死
            if (poolEntry.isMarkedEvicted() || (elapsedMillis(poolEntry.lastAccessed, now) > ALIVE_BYPASS_WINDOW_MS && !isConnectionAlive(poolEntry.connection))) {
               closeConnection(poolEntry, poolEntry.isMarkedEvicted() ? EVICTED_CONNECTION_MESSAGE : DEAD_CONNECTION_MESSAGE);
               //刷新超时时间
               timeout = hardTimeout - elapsedMillis(startTime);
            }
            else {
               metricsTracker.recordBorrowStats(poolEntry, startTime);
               return poolEntry.createProxyConnection(leakTaskFactory.schedule(poolEntry), now);
            }
            //如果没超时则再次获取
         } while (timeout > 0L);
		 //超时时间到仍未获取到链接则抛出 TimeoutException
         metricsTracker.recordBorrowTimeoutStats(startTime);
         throw createTimeoutException(startTime);
      }
      catch (InterruptedException e) {
         Thread.currentThread().interrupt();
         throw new SQLException(poolName + " - Interrupted during connection acquisition", e);
      }
      finally {
         suspendResumeLock.release();
      }
   }

/**
* startTime 上次使用时间
* endTime   当前时间
*/
static long elapsedMillis(long startTime, long endTime) {
    return CLOCK.elapsedMillis0(startTime, endTime);
}

 boolean isConnectionAlive(final Connection connection)
   {
      try {
         try {
            //如果支持Connection networkTimeout,则优先使用并设置
            setNetworkTimeout(connection, validationTimeout);
            final int validationSeconds = (int) Math.max(1000L, validationTimeout) / 1000;
	    //如果jdbc实现支持jdbc4 则使用jdbc4 Connection的isValid方法检测
            if (isUseJdbc4Validation) {
               return connection.isValid(validationSeconds);
            }
	    //查询数据库检测连接可用性
            try (Statement statement = connection.createStatement()) {
              //如果不支持Connection networkTimeout 则设置Statement queryTimeout
               if (isNetworkTimeoutSupported != TRUE) {
                  setQueryTimeout(statement, validationSeconds);
               }
               statement.execute(config.getConnectionTestQuery());
            }
         }
         finally {
            setNetworkTimeout(connection, networkTimeout);
            if (isIsolateInternalQueries && !isAutoCommit) {
               connection.rollback();
            }
         }
         return true;
      }
      catch (Exception e) {
         lastConnectionFailure.set(e);
         LOGGER.warn("{} - Failed to validate connection {} ({}). Possibly consider using a shorter maxLifetime value.",
                     poolName, connection, e.getMessage());
         //捕获到异常，说明链接不可用。（connection is unavailable）
         return false;
      }
   }

 private final class HouseKeeper implements Runnable
   {
      //默认30s,执行一次
      private volatile long previous = plusMillis(currentTime(), -HOUSEKEEPING_PERIOD_MS);
      @Override
      public void run()
      {
         try {
            //省略......
            String afterPrefix = "Pool ";
            if (idleTimeout > 0L && config.getMinimumIdle() < config.getMaximumPoolSize()) {
               logPoolState("Before cleanup ");
               afterPrefix = "After cleanup  ";
	       //空闲链接数
               final List<PoolEntry> notInUse = connectionBag.values(STATE_NOT_IN_USE);
               int toRemove = notInUse.size() - config.getMinimumIdle();
               for (PoolEntry entry : notInUse) {
                  if (toRemove > 0 && elapsedMillis(entry.lastAccessed, now) > idleTimeout && connectionBag.reserve(entry)) {
                     //关闭过多的空闲超时链接
                     closeConnection(entry, "(connection has passed idleTimeout)");
                     toRemove--;
                  }
               }
            }
	    //记录pool状态信息
            logPoolState(afterPrefix);
	    //补充空闲链接
            fillPool(); 
         }
         catch (Exception e) {
            LOGGER.error("Unexpected exception in housekeeping task", e);
         }
      }
   }

 public HikariPool(final HikariConfig config)
   {
      super(config);
      this.connectionBag = new ConcurrentBag<>(this);
      this.suspendResumeLock = config.isAllowPoolSuspension() ? new SuspendResumeLock() : SuspendResumeLock.FAUX_LOCK;
      //执行初始化
      this.houseKeepingExecutorService = initializeHouseKeepingExecutorService();
      //省略......
      }
   }

private ScheduledExecutorService initializeHouseKeepingExecutorService() {
        if (this.config.getScheduledExecutor() == null) {
            ThreadFactory threadFactory = (ThreadFactory)Optional.ofNullable(this.config.getThreadFactory()).orElseGet(() -> {
                return new DefaultThreadFactory(this.poolName + " housekeeper", true);
            });
            //ScheduledThreadPoolExecutor是ThreadPoolExecutor类的子类，Java推荐仅在开发定时任务程序时采用ScheduledThreadPoolExecutor类
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1, threadFactory, new DiscardPolicy());
            //传入false，则执行shutdown()方法之后，待处理的任务将不会被执行
            executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
            //取消任务后，判断是否需要从阻塞队列中移除任务
            executor.setRemoveOnCancelPolicy(true);
            return executor;
        } else {
            return this.config.getScheduledExecutor();
        }
    }

public class HikariDataSource extends HikariConfig implements DataSource, Closeable {
   private final AtomicBoolean isShutdown = new AtomicBoolean();
   //final修饰，构造时决定,如果使用无参构造为null，使用有参构造和pool一样
   private final HikariPool fastPathPool;
   //volatile修饰,无参构造不会设置pool，在getConnection时构造pool，有参构造和fastPathPool一样。
   private volatile HikariPool pool;
   public HikariDataSource() {
      super();
      fastPathPool = null;
   }
   public HikariDataSource(HikariConfig configuration) {
      configuration.validate();
      configuration.copyStateTo(this);
      pool = fastPathPool = new HikariPool(this);
      this.seal();
   }
}