對象池顧名思義就是存放對象的池,與我們常聽到的線程池、資料庫連接配接池、http連接配接池等一樣,都是典型的池化設計思想。
對象池的優點就是可以集中管理池中對象,減少頻繁建立和銷毀長期使用的對象,進而提升複用性,以節約資源的消耗,可以有效避免頻繁為對象配置設定記憶體和釋放堆中記憶體,進而減輕jvm垃圾收集器的負擔,避免記憶體抖動。
Apache Common Pool2 是Apache提供的一個通用對象池技術實作,可以友善定制化自己需要的對象池,大名鼎鼎的 Redis 用戶端 Jedis 内部連接配接池就是基于它來實作的。
核心接口
Apache Common Pool2 的核心内部類如下:
ObjectPool:對象池接口,對象池實體,取用對象的地方
對象的提供與歸還(工廠來操作):borrowObject returnObject
建立對象(使用工廠來建立):addObject
銷毀對象(使用工廠來銷毀):invalidateObject
池中空閑對象數量、被使用對象數量:getNumActive getNumIdle
PooledObject:被包裝的對象,是池中的對象,除了對象本身之外包含了建立時間、上次被調用時間等衆多資訊
PooledObjectFactory:對象工廠,管理對象的生命周期,提供了對象建立、銷毀、驗證、鈍化、激活等一系列功能
BaseObjectPoolConfig:提供一些必要的配置,例如空閑隊列是否先進先出、工廠建立對象前是否需要測試、對象從對象池取出時是否測試等基礎屬性,GenericObjectPoolConfig繼承了本類做了預設配置,我們在實際使用中繼承它即可,可以結合業務情況擴充對象池配置,例如資料庫連接配接池線程字首、字元串池長度或名稱規則等
KeyedObjectPool:鍵值對形式的對象池接口,使用場景很少
KeyedPooledObjectFactory:同上,為鍵值對對象池管理對象的工廠
池對象的狀态
檢視源碼PooledObjectState枚舉下列出了池對象所有可能處于的狀态。
public enum PooledObjectState {
//在空閑隊列中,還未被使用
IDLE,
//使用中
ALLOCATED,
//在空閑隊列中,目前正在測試是否滿足被驅逐的條件
EVICTION,
//不在空閑隊列中,目前正在測試是否可能被驅逐。因為在測試過程中,試圖借用對象,并将其從隊列中删除。
//回收測試完成後,它應該被傳回到隊列的頭部。
EVICTION_RETURN_TO_HEAD,
//在隊列中,正在被校驗
VALIDATION,
//不在隊列中,目前正在驗證。該對象在驗證時被借用,由于配置了testOnBorrow,
//是以将其從隊列中删除并預先配置設定。一旦驗證完成,就應該配置設定它。
VALIDATION_PREALLOCATED,
//不在隊列中,目前正在驗證。在之前測試是否将該對象從隊列中移除時,曾嘗試借用該對象。
//一旦驗證完成,它應該被傳回到隊列的頭部。
VALIDATION_RETURN_TO_HEAD,
//無效狀态(如驅逐測試或驗證),并将/已被銷毀
INVALID,
//判定為無效,将會被設定為廢棄
ABANDONED,
//正在使用完畢,傳回池中
RETURNING
}
狀态了解
- abandoned :被借出後,長時間未被使用則被标記為該狀态。如代碼所示,當該對象處于
狀态,即被借出使用中,距離上次被使用的時間超過了設定的ALLOCATED
則被标記為廢棄。getRemoveAbandonedTimeout
private void removeAbandoned(final AbandonedConfig abandonedConfig) {
// Generate a list of abandoned objects to remove
final long now = System.currentTimeMillis();
final long timeout =
now - (abandonedConfig.getRemoveAbandonedTimeout() * 1000L);
final ArrayList<PooledObject<T>> remove = new ArrayList<>();
final Iterator<PooledObject<T>> it = allObjects.values().iterator();
while (it.hasNext()) {
final PooledObject<T> pooledObject = it.next();
synchronized (pooledObject) {
if (pooledObject.getState() == PooledObjectState.ALLOCATED &&
pooledObject.getLastUsedTime() <= timeout) {
pooledObject.markAbandoned();
remove.add(pooledObject);
}
}
}
```
## 流程了解
1.對象真實是存儲在哪裡?
```java
private PooledObject<T> create() throws Exception {
.....
final PooledObject<T> p;
try {
p = factory.makeObject();
.....
allObjects.put(new IdentityWrapper<>(p.getObject()), p);
return p;
}
我們檢視allObjects,所有對象都存儲于ConcurrentHashMap,除了被殺掉的對象。
/*
* All of the objects currently associated with this pool in any state. It
* excludes objects that have been destroyed. The size of
* {@link #allObjects} will always be less than or equal to {@link
* #_maxActive}. Map keys are pooled objects, values are the PooledObject
* wrappers used internally by the pool.
*/
private final Map<IdentityWrapper<T>, PooledObject<T>> allObjects =
new ConcurrentHashMap<>();
2.取用對象的邏輯歸納如下
首先根據AbandonedConfig配置判斷是否取用對象前執行清理操作
再從idleObject中嘗試擷取對象,擷取不到就建立新的對象
判斷blockWhenExhausted是否設定為true,(這個配置的意思是當對象池的active狀态的對象數量已經達到最大值maxinum時是否進行阻塞直到有空閑對象)
是的話按照設定的borrowMaxWaitMillis屬性等待可用對象
有可用對象後調用工廠的factory.activateObject方法激活對象
當getTestOnBorrow設定為true時,調用factory.validateObject(p)對對象進行校驗,通過校驗後執行下一步
調用updateStatsBorrow方法,在對象被成功借出後更新一些統計項,例如傳回對象池的對象個數等
//....
private final LinkedBlockingDeque<PooledObject<T>> idleObjects;
//....
public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
assertOpen();
final AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
(getNumIdle() < 2) &&
(getNumActive() > getMaxTotal() - 3) ) {
removeAbandoned(ac);
}
PooledObject<T> p = null;
// Get local copy of current config so it is consistent for entire
// method execution
final boolean blockWhenExhausted = getBlockWhenExhausted();
boolean create;
final long waitTime = System.currentTimeMillis();
while (p == null) {
create = false;
p = idleObjects.pollFirst();
if (p == null) {
p = create();
if (p != null) {
create = true;
}
}
if (blockWhenExhausted) {
if (p == null) {
if (borrowMaxWaitMillis < 0) {
p = idleObjects.takeFirst();
} else {
p = idleObjects.pollFirst(borrowMaxWaitMillis,
TimeUnit.MILLISECONDS);
}
}
if (p == null) {
throw new NoSuchElementException(
"Timeout waiting for idle object");
}
} else {
if (p == null) {
throw new NoSuchElementException("Pool exhausted");
}
}
if (!p.allocate()) {
p = null;
}
if (p != null) {
try {
factory.activateObject(p);
} catch (final Exception e) {
try {
destroy(p, DestroyMode.NORMAL);
} catch (final Exception e1) {
// Ignore - activation failure is more important
}
p = null;
if (create) {
final NoSuchElementException nsee = new NoSuchElementException(
"Unable to activate object");
nsee.initCause(e);
throw nsee;
}
}
if (p != null && getTestOnBorrow()) {
boolean validate = false;
Throwable validationThrowable = null;
try {
validate = factory.validateObject(p);
} catch (final Throwable t) {
PoolUtils.checkRethrow(t);
validationThrowable = t;
}
if (!validate) {
try {
destroy(p, DestroyMode.NORMAL);
destroyedByBorrowValidationCount.incrementAndGet();
} catch (final Exception e) {
// Ignore - validation failure is more important
}
p = null;
if (create) {
final NoSuchElementException nsee = new NoSuchElementException(
"Unable to validate object");
nsee.initCause(validationThrowable);
throw nsee;
}
}
}
}
}
updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
return p.getObject();
}
3.工廠的passivateObject(PooledObject p)和passivateObject(PooledObject p)即對象的激活和鈍化方法有什麼用?
如圖在對象使用完被傳回對象池時,如果校驗失敗直接銷毀,如果校驗通過需要先鈍化對象再存入空閑隊列。至于激活對象的方法在上述取用對象時也會先激活再被取出。是以我們可以發現處于空閑和使用中的對象他們除了狀态不一緻,我們也可以通過激活和鈍化的方式在他們之間增加新的差異,例如我們要做一個Elasticsearch連接配接池,每個對象就是一個帶有ip和端口的連接配接執行個體,很顯然通路es叢集是多個不同的ip,是以每次通路的ip不一定相同,我們則可以在激活操作為對象指派ip和端口,鈍化操作中将ip和端口歸為預設值或者空,這樣流程更為标準。
public void returnObject(final T obj) {
final PooledObject<T> p = allObjects.get(new IdentityWrapper<>(obj));
//....
//校驗失敗直接銷毀 return
//...
try {
factory.passivateObject(p);
} catch (final Exception e1) {
swallowException(e1);
try {
destroy(p, DestroyMode.NORMAL);
} catch (final Exception e) {
swallowException(e);
}
try {
ensureIdle(1, false);
} catch (final Exception e) {
swallowException(e);
}
updateStatsReturn(activeTime);
return;
}
//......
//傳回空閑隊列
}
對象池相關配置項
對象池提供了許多配置項,在我們使用的GenericObjectPool預設基礎對象池中可以通過構造方法傳參傳入GenericObjectPoolConfig,當然我們也可以看GenericObjectPoolConfig底層實作的基礎類BaseObjectPoolConfig,具體包含如下配置:
maxTotal:對象池中最大使用數量,預設為8
maxIdle:對象中空閑對象最大數量,預設為8
minIdle:對象池中空閑對象最小數量,預設為8
lifo:當去擷取對象池中的空閑執行個體時,是否需要遵循後進先出的原則,預設為true
blockWhenExhausted:當對象池處于exhausted狀态,即可用執行個體為空時,是否阻塞來擷取執行個體的線程,預設 true
fairness:當對象池處于exhausted狀态,即可用執行個體為空時,大量線程在同時阻塞等待擷取可用的執行個體,fairness配置來控制是否啟用公平鎖算法,即先到先得,預設為false。這一項的前提是blockWhenExhausted配置為true
maxWaitMillis:最大阻塞時間,當對象池處于exhausted狀态,即可用執行個體為空時,大量線程在同時阻塞等待擷取可用的執行個體,如果阻塞時間超過了maxWaitMillis将會抛出異常。當此值為負數時,代表無限期阻塞直到可用。預設為-1
testOnCreate:建立對象前是否校驗(即調用工廠的validateObject()方法),如果檢驗失敗,那麼borrowObject()傳回将失敗,預設為false
testOnBorrow:取用對象前是否檢驗,預設為false
testOnReturn:傳回對象池前是否檢驗,即調用工廠的returnObject(),若檢驗失敗會銷毀對象而不是傳回池中,預設為false
timeBetweenEvictionRunsMillis:驅逐周期,預設為-1代表不進行驅逐測試
testWhileIdle:處于idle隊列中即閑置的對象是否被驅逐器進行驅逐驗證,當該對象上次運作時間距目前超過了setTimeBetweenEvictionRunsMillis(long))設定的值,将會被驅逐驗證,調用validateObject()方法,若驗證成功,對象将會銷毀。預設為false
使用步驟
建立工廠類:通過繼承BaseGenericObjectPool或者實作基礎接口PooledObjectFactory,并按照業務需求重寫對象的建立、銷毀、校驗、激活、鈍化方法,其中銷毀多為連接配接的關閉、置空等。
建立池:通過繼承GenericObjectPool或者實作基礎接口ObjectPool,建議使用前者,它為我們提供了空閑對象驅逐檢測機制(即将空閑隊列中長時間未使用的對象銷毀,降低記憶體占用),以及提供了很多對象的基本資訊,例如對象最後被使用的時間、使用對象前是否檢驗等。
建立池相關配置(可選):通過繼承GenericObjectPoolConfig或者繼承BaseObjectPoolConfig,來增加對線程池的配置控制,建議使用前者,它為我們實作了基本方法,隻需要自己添加需要的屬性即可。
建立包裝類(可選):即要存在于對象池中的對象,在實際對象之外添加許多基礎屬性,便于了解對象池中對象的實時狀态。
注意事項
我們雖然使用了預設實作,但是也應該結合實際生産情況進行優化,不能使用了線程池而性能卻更低了。在使用中我們應注意以下事項:
要為對象池設定空閑隊列最大最小值,預設最大最小值,預設最大為8往往不能滿足需要
private volatile int maxIdle = GenericObjectPoolConfig.DEFAULT_MAX_IDLE;
private volatile int minIdle = GenericObjectPoolConfig.DEFAULT_MIN_IDLE;
public static final int DEFAULT_MAX_IDLE = 8;
public static final int DEFAULT_MIN_IDLE = 0;
對象池設定maxWaitMillis屬性,即取用對象最大等待時間
使用完對象及時釋放對象,将對象傳回池中,特别是發生了異常也要通過try..chatch..finally的方式確定釋放,避免占用資源
我們展開講講注意事項,首先為什麼要設定maxWaitMillis,我們取用對象使用的如下方法
public T borrowObject() throws Exception {
return borrowObject(getMaxWaitMillis());
}
我們再來檢視取用對象邏輯,
blockWhenExhausted
預設為true,意思是當池中不存在空閑對象時,又來取用對象,線程将會被阻塞直到有新的可用對象。從上我們得知
-1L
将會執行
idleObjects.takeFirst()
public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
//.......
final boolean blockWhenExhausted = getBlockWhenExhausted();
boolean create;
final long waitTime = System.currentTimeMillis();
while (p == null) {
//.......
if (blockWhenExhausted) {
if (p == null) {
if (borrowMaxWaitMillis < 0) {
p = idleObjects.takeFirst();
} else {
p = idleObjects.pollFirst(borrowMaxWaitMillis,
TimeUnit.MILLISECONDS);
}
}
}
}
}
如下,阻塞隊列将會一直阻塞,直到有了空閑對象才停止阻塞,這樣的設定将會在吞吐提高時造成大面積阻塞影響
public E takeFirst() throws InterruptedException {
lock.lock();
try {
E x;
while ( (x = unlinkFirst()) == null) {
notEmpty.await();
}
return x;
} finally {
lock.unlock();
}
}
還有一個注意事項就是要記得回收資源,即調用
public void returnObject(final T obj)
方法,原因顯而易見,對象池對我們是否使用完了對象是無感覺的,需要我們調用該方法回收對象,特别是發生異常也要保證回收,是以最佳實踐如下:
try{
item = pool.borrowObject();
} catch(Exception e) {
log.error("....");
} finally {
pool.returnObject(item);
}
執行個體使用
執行個體1:實作一個簡單的字元串池
建立字元串工廠
package com.anqi.demo.demopool2.pool.fac;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
* 字元串池工廠
*/
public class StringPoolFac extends BasePooledObjectFactory<String> {
public StringPoolFac() {
super();
}
@Override
public String create() throws Exception {
return "str-val-";
}
@Override
public PooledObject<String> wrap(String s) {
return new DefaultPooledObject<>(s);
}
@Override
public void destroyObject(PooledObject<String> p) throws Exception {
}
@Override
public boolean validateObject(PooledObject<String> p) {
return super.validateObject(p);
}
@Override
public void activateObject(PooledObject<String> p) throws Exception {
super.activateObject(p);
}
@Override
public void passivateObject(PooledObject<String> p) throws Exception {
super.passivateObject(p);
}
}
建立字元串池
package com.anqi.demo.demopool2.pool;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
/**
* 字元串池
*/
public class StringPool extends GenericObjectPool<String> {
public StringPool(PooledObjectFactory<String> factory) {
super(factory);
}
public StringPool(PooledObjectFactory<String> factory, GenericObjectPoolConfig<String> config) {
super(factory, config);
}
}
測試主類
首先我們我們設定
setMaxTotal
為2,即最多有兩個對象被取出使用,設定
setMaxWaitMillis
為3S,即最多被阻塞3S,我們循環取用3次,并不釋放資源
import com.anqi.demo.demopool2.pool.fac.StringPoolFac;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class StringPoolTest {
private static final Logger LOG = LoggerFactory.getLogger(StringPoolTest.class);
public static void main(String[] args) {
StringPoolFac fac = new StringPoolFac();
GenericObjectPoolConfig<String> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(2);
config.setMinIdle(1);
config.setMaxWaitMillis(3000);
StringPool pool = new StringPool(fac, config);
for (int i = 0; i < 3; i++) {
String s = "";
try {
s = pool.borrowObject();
LOG.info("str:{}", s);
} catch (Exception e) {
e.printStackTrace();
} finally {
// if (!s.equals("")) {
// pool.returnObject(s);
// }
}
}
}
}
結果如下,在兩次成功調用之後,阻塞3S,接着程式報錯停止。這是因為可用資源最多為2,若不釋放将會無資源可用,新來的調用者會被阻塞3S,之後報錯取用失敗。
16:18:42.499 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:18:42.505 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
java.util.NoSuchElementException: Timeout waiting for idle object
我們放開注釋,釋放資源後得到正常執行結果
16:20:52.384 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:20:52.388 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:20:52.388 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-