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();
   }
}