?完整原始碼,請幫我點個star哦！
?原文地址為https://www.cnblogs.com/haixiang/p/14783955.html，轉載請註明出處!
簡介
物件池顧名思義就是存放物件的池，與我們常聽到的執行緒池、資料庫連線池、http連線池等一樣，都是典型的池化設計思想。
物件池的優點就是可以集中管理池中物件，減少頻繁建立和銷燬長期使用的物件，從而提升複用性，以節約資源的消耗，可以有效避免頻繁為物件分配記憶體和釋放堆中記憶體，進而減輕jvm垃圾收集器的負擔，避免記憶體抖動。
Apache Common Pool2 是Apache提供的一個通用物件池技術實現，可以方便定製化自己需要的物件池，大名鼎鼎的 Redis 客戶端 Jedis 內部連線池就是基於它來實現的。
核心介面
Apache Common Pool2 的核心內部類如下：
-
ObjectPool：物件池介面，物件池實體，取用物件的地方
- 物件的提供與歸還(工廠來操作)：
borrowObjectreturnObject - 建立物件(使用工廠來建立)：
addObject - 銷燬物件(使用工廠來銷燬)：
invalidateObject - 池中空閒物件數量、被使用物件數量：
getNumActivegetNumIdle
- 物件的提供與歸還(工廠來操作)：
-
PooledObject：被包裝的物件，是池中的物件，除了物件本身之外包含了建立時間、上次被呼叫時間等眾多資訊
-
PooledObjectFactory：物件工廠，管理物件的生命週期，提供了物件建立、銷燬、驗證、鈍化、啟用等一系列功能
-
BaseObjectPoolConfig：提供一些必要的配置，例如空閒佇列是否先進先出、工廠建立物件前是否需要測試、物件從物件池取出時是否測試等基礎屬性，
GenericObjectPoolConfig繼承了本類做了預設配置，我們在實際使用中繼承它即可，可以結合業務情況擴充套件物件池配置，例如資料庫連線池執行緒字首、字串池長度或名稱規則等 -
KeyedObjectPool<K,V>：鍵值對形式的物件池介面，使用場景很少
-
KeyedPooledObjectFactory<K,V>：同上，為鍵值對物件池管理物件的工廠
池物件的狀態
檢視原始碼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.物件真實是儲存在哪裡？
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<T> p)和passivateObject(PooledObject<T> 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());
}
可以看到預設的最大等待時間為-1L
private volatile long maxWaitMillis =
BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS;
//....
public static final long DEFAULT_MAX_WAIT_MILLIS = -1L;
我們再來檢視取用物件邏輯,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-