public Connection getConnection(final long hardTimeout) throws SQLException
   {
      //這里是防止線(xiàn)程池處于暫停狀態(tài)（通常不允許線(xiàn)程池可暫停）
      suspendResumeLock.acquire();
      final long startTime = currentTime();
      try {
         long timeout = hardTimeout;
         do {
            //PoolEntry 用于跟蹤connection實(shí)例，里面包裝了Connection;
            //從connectionBag中獲取一個(gè)對(duì)象，并且檢測(cè)是否可用
            PoolEntry poolEntry = connectionBag.borrow(timeout, MILLISECONDS);
            if (poolEntry == null) {
               break; // We timed out... break and throw exception
            }
            final long now = currentTime();
            //1、已被標(biāo)記為驅(qū)逐 2、已超過(guò)最大存活時(shí)間 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);
               //刷新超時(shí)時(shí)間
               timeout = hardTimeout - elapsedMillis(startTime);
            }
            else {
               metricsTracker.recordBorrowStats(poolEntry, startTime);
               return poolEntry.createProxyConnection(leakTaskFactory.schedule(poolEntry), now);
            }
            //如果沒(méi)超時(shí)則再次獲取
         } while (timeout > 0L);
		 //超時(shí)時(shí)間到仍未獲取到鏈接則拋出 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 上次使用時(shí)間
* endTime   當(dāng)前時(shí)間
*/
static long elapsedMillis(long startTime, long endTime) {
    return CLOCK.elapsedMillis0(startTime, endTime);
}

 boolean isConnectionAlive(final Connection connection)
   {
      try {
         try {
            //如果支持Connection networkTimeout,則優(yōu)先使用并設(shè)置
            setNetworkTimeout(connection, validationTimeout);
            final int validationSeconds = (int) Math.max(1000L, validationTimeout) / 1000;
	    //如果jdbc實(shí)現(xiàn)支持jdbc4 則使用jdbc4 Connection的isValid方法檢測(cè)
            if (isUseJdbc4Validation) {
               return connection.isValid(validationSeconds);
            }
	    //查詢(xún)數(shù)據(jù)庫(kù)檢測(cè)連接可用性
            try (Statement statement = connection.createStatement()) {
              //如果不支持Connection networkTimeout 則設(shè)置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());
         //捕獲到異常，說(shuō)明鏈接不可用。（connection is unavailable）
         return false;
      }
   }

 private final class HouseKeeper implements Runnable
   {
      //默認(rèn)30s,執(zhí)行一次
      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  ";
	       //空閑鏈接數(shù)
               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)) {
                     //關(guān)閉過(guò)多的空閑超時(shí)鏈接
                     closeConnection(entry, "(connection has passed idleTimeout)");
                     toRemove--;
                  }
               }
            }
	    //記錄pool狀態(tài)信息
            logPoolState(afterPrefix);
	    //補(bǔ)充空閑鏈接
            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;
      //執(zhí)行初始化
      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類(lèi)的子類(lèi)，Java推薦僅在開(kāi)發(fā)定時(shí)任務(wù)程序時(shí)采用ScheduledThreadPoolExecutor類(lèi)
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1, threadFactory, new DiscardPolicy());
            //傳入false，則執(zhí)行shutdown()方法之后，待處理的任務(wù)將不會(huì)被執(zhí)行
            executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
            //取消任務(wù)后，判斷是否需要從阻塞隊(duì)列中移除任務(wù)
            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修飾，構(gòu)造時(shí)決定,如果使用無(wú)參構(gòu)造為null，使用有參構(gòu)造和pool一樣
   private final HikariPool fastPathPool;
   //volatile修飾,無(wú)參構(gòu)造不會(huì)設(shè)置pool，在getConnection時(shí)構(gòu)造pool，有參構(gòu)造和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();
   }
}