maxLifetime參數(shù)

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

HikariPool類中，當我們初始化連接池的時候，它的構造方法中，實例化了this.POOL_ENTRY_CREATOR = new HikariPool.PoolEntryCreator();該類實現(xiàn)了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;

}

復制代碼

在其中調(diào)用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;

}

}

復制代碼

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

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

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

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

連接斷開；

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

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

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

validationTimeout

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

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

leakDetectionThreshold`

該參數(shù)主要用來開啟連接泄漏檢測，在通過getConnection()獲取連接的時候，會繼續(xù)調(diào)用另外一個createProxyConnection()方法獲取連接,這里我們關注入?yún)his.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);

}

復制代碼

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

private ProxyLeakTask(ProxyLeakTask parent, PoolEntry poolEntry) {

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

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

//延時執(zhí)行

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中的一個內(nèi)部類，實現(xiàn)了Runnable接口，主要就是對連接進行管理。在初始化HikariPool的時候，會創(chuàng)建一個scheduleWithFixedDelay任務(已固定延遲時間執(zhí)行，就是說兩個任務之間的時間間隔是固定的，但每個任務的執(zhí)行時長可能是不定的，與scheduleFixedRate的區(qū)別就是，不管任務是否執(zhí)行完，到點就執(zhí)行下一次任務)，默認30s執(zhí)行一次,刷新配置，進行判斷。

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

//創(chuàng)建定時任務類

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參數(shù)給這個方法，執(zhí)行shutdown()方法之后，待處理的任務將不會被執(zhí)行。

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方法中，會先對時間進行判斷。

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

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

private HouseKeeper() {

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

}

復制代碼

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

//檢測逆行時間，根據(jù)NTP規(guī)范允許+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，取出當前空閑連接

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

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

則關閉該連接

最后再新創(chuàng)建連接

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)) {

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;

}

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) {

//取出空閑連接 連接狀態(tài)，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判斷，連接狀態(tài)修改

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不一致問題

當前版本在應用初始化的時候，連接池也會進行初始化，但是當我們配置的數(shù)據(jù)源屬性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);

//生成的個數(shù)減去了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不能大于數(shù)據(jù)庫的time_wait，查詢mysql配置show variables like ‘%timeout%’，默認為8小時。

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

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

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

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

after_transaction，每次事務結(jié)束都會釋放鏈接

after_statement，在每次JDBC調(diào)用后，都會主動的釋放連接

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

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

參考資料

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

HikariCP是如何管理數(shù)據(jù)庫連接的？

關于找一找教程網(wǎng)

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

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

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

總結(jié)

以上是生活随笔為你收集整理的hikaril连接sql2000_hikari连接池解析(版本：HikariCP-2.5.1.jar)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。