hikaril連接sql2000_hikari連接池解析(版本：HikariCP-2.5.1.jar)

maxLifetime參數

maxLifetime參數必須小于數據庫的time_wait,默認是1800000，即30分鐘。如果設置為0，表示存活時間無限大。如果不等于0且小于30秒則會被重置回30分鐘。HikariConfig類中有該參數的校驗規則。

HikariPool類中，當我們初始化連接池的時候，它的構造方法中，實例化了this.POOL_ENTRY_CREATOR = new HikariPool.PoolEntryCreator();該類實現了Callable接口，用來初始化連接。

public Boolean call() throws Exception {

for(long sleepBackoff = 250L; HikariPool.this.poolState == 0 && HikariPool.this.totalConnections.get() < HikariPool.this.config.getMaximumPoolSize(); sleepBackoff = Math.min(TimeUnit.SECONDS.toMillis(10L), Math.min(HikariPool.this.connectionTimeout, (long)((double)sleepBackoff * 1.5D)))) {

PoolEntry poolEntry = HikariPool.this.createPoolEntry();

if (poolEntry != null) {

HikariPool.this.totalConnections.incrementAndGet();

HikariPool.this.connectionBag.add(poolEntry);

return Boolean.TRUE;

}

UtilityElf.quietlySleep(sleepBackoff);

}

return Boolean.FALSE;

}

復制代碼

在其中調用createPoolEntry()生成一個連接。

private PoolEntry createPoolEntry() {

try {

final PoolEntry poolEntry = this.newPoolEntry();

long maxLifetime = this.config.getMaxLifetime();

if (maxLifetime > 0L) {

long variance = maxLifetime > 10000L ? ThreadLocalRandom.current().nextLong(maxLifetime / 40L) : 0L;

long lifetime = maxLifetime - variance;

poolEntry.setFutureEol(this.houseKeepingExecutorService.schedule(new Runnable() {

public void run() {

HikariPool.this.softEvictConnection(poolEntry, "(connection has passed maxLifetime)", false);

}

}, lifetime, TimeUnit.MILLISECONDS));

}

this.LOGGER.debug("{} - Added connection {}", this.poolName, poolEntry.connection);

return poolEntry;

} catch (Exception var8) {

if (this.poolState == 0) {

this.LOGGER.debug("{} - Cannot acquire connection from data source", this.poolName, var8);

}

return null;

}

復制代碼

在該方法中，設置了一個延時任務，具體的延時執行時間是根據maxLifetime來計算，觸發時間距離maxlifetime的差值是根據 maxLifetime > 10_000 ? ThreadLocalRandom.current().nextLong( maxLifetime / 40 ) : 0;

來計算(up to 2.5% of the maxlifetime)，在連接存活將要到達maxLifetime之前觸發evit，用來防止出現大面積的connection因maxLifetime同一時刻失效。

當被觸發時，會標記evict為true，標記為evict只是表示連接池中的該連接不可用，但還在連接池當中，還會被borrow出來，只是getConnection的時候判斷了，如果是isMarkedEvicted，則會從連接池中移除該連接，然后close掉。

HikariCP中通過獨立的線程池closeConnectionExecutor進行物理連接的關閉。出現以下三種情況時會觸發連接的自動關閉：

連接斷開；

連接存活時間超出最大生存時間(maxLifeTime)

連接空閑時間超出最大空閑時間(idleTimeout)

closeConnectionExecutor關閉連接后，會調用fillPool()方法對連接池進行連接填充

validationTimeout

validationTimeout用來指定驗證連接有效性的超時時間(默認是5秒，最小不能小于250毫秒)，在HikariPool.getConnection方法中會調用isConnectionAlive(Connection connection)對連接進行驗證。

如果是jdbc4的話，可以使用isUseJdbc4Validation，是直接利用connection.isValid(validationSeconds)來驗證連接的有效性；否則的話則用connectionTestQuery查詢語句來查詢驗證。

leakDetectionThreshold`

該參數主要用來開啟連接泄漏檢測，在通過getConnection()獲取連接的時候，會繼續調用另外一個createProxyConnection()方法獲取連接,這里我們關注入參this.leakTask.schedule(poolEntry)。

public final Connection getConnection(long hardTimeout) throws SQLException {

this.suspendResumeLock.acquire();

long startTime = clockSource.currentTime();

try {

long timeout = hardTimeout;

do {

PoolEntry poolEntry = (PoolEntry)this.connectionBag.borrow(timeout, TimeUnit.MILLISECONDS);

if (poolEntry == null) {

break;

}

long now = clockSource.currentTime();

if (!poolEntry.isMarkedEvicted() && (clockSource.elapsedMillis(poolEntry.lastAccessed, now) <= this.ALIVE_BYPASS_WINDOW_MS || this.isConnectionAlive(poolEntry.connection))) {

this.metricsTracker.recordBorrowStats(poolEntry, startTime);

//獲取連接

Connection var10 = poolEntry.createProxyConnection(this.leakTask.schedule(poolEntry), now);

return var10;

}

復制代碼

該schedule方法返回一個ProxyLeakTask對象

//返回 ProxyLeakTask

ProxyLeakTask schedule(PoolEntry bagEntry) {

return this.leakDetectionThreshold == 0L ? NO_LEAK : new ProxyLeakTask(this, bagEntry);

}

復制代碼

這里判斷leakDetectionThreshold參數是否為0，默認是0，不開啟檢測。否則，就會開啟一個延時執行任務,時間正好為設置的leakDetectionThreshold值，該任務的作用就是用來拋出Apparent connection leak detected異常。

private ProxyLeakTask(ProxyLeakTask parent, PoolEntry poolEntry) {

this.exception = new Exception("Apparent connection leak detected");

this.connectionName = poolEntry.connection.toString();

//延時執行

this.scheduledFuture = parent.executorService.schedule(this, parent.leakDetectionThreshold, TimeUnit.MILLISECONDS);

}

復制代碼

截取一部分異常，如下

22:14:49.096 volte-cmd-service-test [HikariPool-1 housekeeper] WARN com.zaxxer.hikari.pool.ProxyLeakTask - Connection leak detection triggered for com.mysql.jdbc.JDBC4Connection@429fe922, stack trace follows

java.lang.Exception: Apparent connection leak detected

at org.hibernate.engine.jdbc.connections.internal.DatasourceConnectionProviderImpl.getConnection(DatasourceConnectionProviderImpl.java:122)

at org.hibernate.internal.AbstractSessionImpl$NonContextualJdbcConnectionAccess.obtainConnection(AbstractSessionImpl.java:386)

at org.hibernate.resource.jdbc.internal.LogicalConnectionManagedImpl.acquireConnectionIfNeeded(LogicalConnectionManagedImpl.java:87)

at org.hibernate.resource.jdbc.internal.LogicalConnectionManagedImpl.getPhysicalConnection(LogicalConnectionManagedImpl.java:112)

at org.hibernate.internal.SessionImpl.connection(SessionImpl.java:489)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:497)

at org.springframework.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:215)

at org.springframework.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:200)

at org.springframework.orm.jpa.vendor.HibernateJpaDialect$HibernateConnectionHandle.doGetConnection(HibernateJpaDialect.java:414)

at org.springframework.orm.jpa.vendor.HibernateJpaDialect.beginTransaction(HibernateJpaDialect.java:177)

復制代碼

也就是從我們獲取這個連接開始，到歸還連接之前的這一段時間，如果超過了leakDetectionThreshold，則會拋出上面的異常。

HouseKeeper

它是HikariPool中的一個內部類，實現了Runnable接口，主要就是對連接進行管理。在初始化HikariPool的時候，會創建一個scheduleWithFixedDelay任務(已固定延遲時間執行，就是說兩個任務之間的時間間隔是固定的，但每個任務的執行時長可能是不定的，與scheduleFixedRate的區別就是，不管任務是否執行完，到點就執行下一次任務)，默認30s執行一次,刷新配置，進行判斷。

public HikariPool(HikariConfig config) {

super(config);

this.ALIVE_BYPASS_WINDOW_MS = Long.getLong("com.zaxxer.hikari.aliveBypassWindowMs", TimeUnit.MILLISECONDS.toMillis(500L));

this.HOUSEKEEPING_PERIOD_MS = Long.getLong("com.zaxxer.hikari.housekeeping.periodMs", TimeUnit.SECONDS.toMillis(30L));

this.POOL_ENTRY_CREATOR = new HikariPool.PoolEntryCreator();

this.connectionBag = new ConcurrentBag(this);

this.totalConnections = new AtomicInteger();

this.suspendResumeLock = config.isAllowPoolSuspension() ? new SuspendResumeLock() : SuspendResumeLock.FAUX_LOCK;

this.checkFailFast();

if (config.getMetricsTrackerFactory() != null) {

this.setMetricsTrackerFactory(config.getMetricsTrackerFactory());

} else {

this.setMetricRegistry(config.getMetricRegistry());

}

this.setHealthCheckRegistry(config.getHealthCheckRegistry());

this.registerMBeans(this);

ThreadFactory threadFactory = config.getThreadFactory();

this.addConnectionExecutor = UtilityElf.createThreadPoolExecutor(config.getMaximumPoolSize(), this.poolName + " connection adder", threadFactory, new DiscardPolicy());

this.closeConnectionExecutor = UtilityElf.createThreadPoolExecutor(config.getMaximumPoolSize(), this.poolName + " connection closer", threadFactory, new CallerRunsPolicy());

//創建定時任務類

if (config.getScheduledExecutorService() == null) {

ThreadFactory threadFactory = threadFactory != null ? threadFactory : new DefaultThreadFactory(this.poolName + " housekeeper", true);

this.houseKeepingExecutorService = new ScheduledThreadPoolExecutor(1, (ThreadFactory)threadFactory, new DiscardPolicy());

//傳遞false參數給這個方法，執行shutdown()方法之后，待處理的任務將不會被執行。

this.houseKeepingExecutorService.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);

//取消任務后，判斷是否需要從阻塞隊列中移除任務

this.houseKeepingExecutorService.setRemoveOnCancelPolicy(true);

} else {

this.houseKeepingExecutorService = config.getScheduledExecutorService();

}

this.leakTask = new ProxyLeakTask(config.getLeakDetectionThreshold(), this.houseKeepingExecutorService);

//初始化HouseKeeper

this.houseKeepingExecutorService.scheduleWithFixedDelay(new HikariPool.HouseKeeper(), 100L, this.HOUSEKEEPING_PERIOD_MS, TimeUnit.MILLISECONDS);

}

復制代碼

時間回撥處理

在HouseKeeper的run方法中，會先對時間進行判斷。

這里主要就是通過一個時間差來判斷這個時間差返回內是否有時間回撥，在初始化的時候會通過下面構造方法生成一個時間戳

// previous=當前時間-30s(默認的定時任務間隔時間)

private HouseKeeper() {

this.previous = HikariPool.clockSource.plusMillis(HikariPool.clockSource.currentTime(), -HikariPool.this.HOUSEKEEPING_PERIOD_MS);

}

復制代碼

當初始化完成的第一次30s后或者上次任務執行完的30s后，再執行該任務，如果當前的時間戳+128ms還要小于previous(上次執行后減去30s的時間戳)+30s,則表示有時間回撥

//檢測逆行時間，根據NTP規范允許+128ms

if (HikariPool.clockSource.plusMillis(now, 128L) < HikariPool.clockSource.plusMillis(this.previous, HikariPool.this.HOUSEKEEPING_PERIOD_MS)) {

HikariPool.this.LOGGER.warn("{} - Retrograde clock change detected (housekeeper delta={}), soft-evicting connections from pool.", HikariPool.this.poolName, HikariPool.clockSource.elapsedDisplayString(this.previous, now));

this.previous = now;

HikariPool.this.softEvictConnections();

HikariPool.this.fillPool();

return;

}

復制代碼

此時，會打印日志，并重置previous為當前時間，設置連接為不可用，再重新生成連接。

保持最小連接

如果時間沒有錯誤，則會判斷idleTimeout，如果大于0，取出當前空閑連接

判斷是否大于最小連接數minimumIdle,如果大于，則繼續對當前的空閑連接基于lastAccessed(最后一次訪問時間)進行排序，再遍歷

如果取出的每個連接的空閑時間已經超過了idleTimeout，并且成功將連接從NOT_IN_USE(閑置中)更改為RESERVED(標記為保留中)

則關閉該連接

最后再新創建連接

public void run() {

try {

//刷新connectionTimeout、validationTimeout

HikariPool.this.connectionTimeout = HikariPool.this.config.getConnectionTimeout();

HikariPool.this.validationTimeout = HikariPool.this.config.getValidationTimeout();

HikariPool.this.leakTask.updateLeakDetectionThreshold(HikariPool.this.config.getLeakDetectionThreshold());

long idleTimeout = HikariPool.this.config.getIdleTimeout();

long now = HikariPool.clockSource.currentTime();

//時鐘回撥判斷

if (HikariPool.clockSource.plusMillis(now, 128L) < HikariPool.clockSource.plusMillis(this.previous, HikariPool.this.HOUSEKEEPING_PERIOD_MS)) {

this.previous = now;

HikariPool.this.softEvictConnections();

HikariPool.this.fillPool();

return;

}

if (now > HikariPool.clockSource.plusMillis(this.previous, 3L * HikariPool.this.HOUSEKEEPING_PERIOD_MS / 2L)) {

HikariPool.this.LOGGER.warn("{} - Thread starvation or clock leap detected (housekeeper delta={}).", HikariPool.this.poolName, HikariPool.clockSource.elapsedDisplayString(this.previous, now));

}

this.previous = now;

String afterPrefix = "Pool ";

if (idleTimeout > 0L) {

//取出空閑連接連接狀態，IN_USE(1:使用中)、NOT_IN_USE(0:閑置中)、REMOVED(-1:已移除)、RESERVED(-1:標記為保留中)

List idleList = HikariPool.this.connectionBag.values(0);

int removable = idleList.size() - HikariPool.this.config.getMinimumIdle();

if (removable > 0) {

HikariPool.this.logPoolState("Before cleanup ");

afterPrefix = "After cleanup ";

//排序

idleList.sort(PoolEntry.LASTACCESS_COMPARABLE);

Iterator var8 = idleList.iterator();

while(var8.hasNext()) {

PoolEntry poolEntry = (PoolEntry)var8.next();

//idleTimeout判斷，連接狀態修改

if (HikariPool.clockSource.elapsedMillis(poolEntry.lastAccessed, now) > idleTimeout && HikariPool.this.connectionBag.reserve(poolEntry)) {

HikariPool.this.closeConnection(poolEntry, "(connection has passed idleTimeout)");

--removable;

if (removable == 0) {

break;//keep min idle cons

}

HikariPool.this.logPoolState(afterPrefix);

HikariPool.this.fillPool();

} catch (Exception var10) {

HikariPool.this.LOGGER.error("Unexpected exception in housekeeping task", var10);

}

復制代碼

問題

minimumIdle不一致問題

當前版本在應用初始化的時候，連接池也會進行初始化，但是當我們配置的數據源屬性minimumIdle

//HikariCP-3.4.5.jar

private synchronized void fillPool()

{

final int connectionsToAdd = Math.min(config.getMaximumPoolSize() - getTotalConnections(), config.getMinimumIdle() - getIdleConnections())

- addConnectionQueueReadOnlyView.size();

if (connectionsToAdd <= 0) logger.debug("{} - Fill pool skipped, pool is at sufficient level.", poolName);

//生成的個數減去了1

for (int i = 0; i < connectionsToAdd; i++) {

addConnectionExecutor.submit((i < connectionsToAdd - 1) ? poolEntryCreator : postFillPoolEntryCreator);

}

//HikariCP-2.5.1.jar 的該方法

for (int i = 0; i < connectionsToAdd; i++) {

addBagItem();

}

復制代碼

超時問題

錯誤日志如下：

java.sql.SQLTransientConnectionException: HikariPool-1 - Connection is not available, request timed out after 30000ms.

復制代碼首先檢查配置是否有問題，maxLifetime不能大于數據庫的time_wait，查詢mysql配置show variables like ‘%timeout%’，默認為8小時。

配置沒有問題，則有可能與HikariCP無關。這個錯誤的產生原因就是請求向池中borrow時，沒有可用連接超時導致。第一點，此時我們要思考我們的連接池數量設置是否合理，與業務量相關；第二點，看我們代碼是否存在慢sql；第三點，與使用的持久層框架有關，分析我們的連接到底是被誰所持有，它的連接管理方法是怎么樣的，什么情況下才會歸還連接。

這篇文章就是因為我遇到這個錯而無法定位才決定好好研究下的，我的這個錯誤產生的原因就是上面的第三點，我的項目采用的是jpa做數據庫交互，且是一個非常簡單的單表查詢，連接應該很快歸還池中才對，但是經過我的測試，當經過數據庫查詢以后，連接并沒有被釋放，反而是在我的整個會話結束后，才會歸還連接。

jpa的核心是hibernate-core，在網上查詢了hibernate的連接釋放策略，知道了原因。hibernate 中連接釋放的策略hibernate. connection. release_ mode有以下四種屬性：

on_close，當Session被顯式關閉或被斷開連接時,才會釋放JDBC連接

after_transaction，每次事務結束都會釋放鏈接

after_statement，在每次JDBC調用后，都會主動的釋放連接

auto,為JTA和CMT事務策略選擇after_statement, 為JDBC事務策略選擇after_transaction

我的springboot項目版本為1.x,即便將hibernate-core升級到較高版本，并開啟事物，也還是基于on_close方式去釋放連接；我測試了2.x版本的，不開啟事物時也是on_close,開啟事物后，就成了after_transaction，具體1.x版本為何開啟事物也不生效還不清楚。

參考資料

流程圖的方式講解，很清晰易懂，版本也比較高

HikariCP是如何管理數據庫連接的？

關于找一找教程網

本站文章僅代表作者觀點，不代表本站立場，所有文章非營利性免費分享。

本站提供了軟件編程、網站開發技術、服務器運維、人工智能等等IT技術文章，希望廣大程序員努力學習，讓我們用科技改變世界。

[hikari連接池解析(版本：HikariCP-2.5.1.jar)]http://www.zyiz.net/tech/detail-143838.html