對象池顧名思義就是存放對象的池，與我們常聽到的線程池、數據庫連接池、http連接池等一樣，都是典型的池化設計思想。
對象池的優(yōu)點就是可以集中管理池中對象，減少頻繁創(chuàng)建和銷毀長期使用的對象，從而提升復用性，以節(jié)約資源的消耗，可以有效避免頻繁為對象分配內存和釋放堆中內存，進而減輕jvm垃圾收集器的負擔，避免內存抖動。
Apache Common Pool2 是Apache提供的一個通用對象池技術實現，可以方便定制化自己需要的對象池，大名鼎鼎的 Redis 客戶端 Jedis 內部連接池就是基于它來實現的。
2021年最新阿里P7 Java面試題流出，附完整答案詳解，看完跳槽吊打面試官
核心接口
Apache Common Pool2 的核心內部類如下：
ObjectPool：對象池接口，對象池實體，取用對象的地方
對象的提供與歸還(工廠來操作)：borrowObjectreturnObject
創(chuàng)建對象(使用工廠來創(chuàng)建)：addObject
銷毀對象(使用工廠來銷毀)：invalidateObject
池中空閑對象數量、被使用對象數量：getNumActivegetNumIdle
PooledObject：被包裝的對象，是池中的對象，除了對象本身之外包含了創(chuàng)建時間、上次被調用時間等眾多信息
PooledObjectFactory：對象工廠，管理對象的生命周期，提供了對象創(chuàng)建、銷毀、驗證、鈍化、激活等一系列功能
BaseObjectPoolConfig：提供一些必要的配置，例如空閑隊列是否先進先出、工廠創(chuàng)建對象前是否需要測試、對象從對象池取出時是否測試等基礎屬性，GenericObjectPoolConfig繼承了本類做了默認配置，我們在實際使用中繼承它即可，可以結合業(yè)務情況擴展對象池配置，例如數據庫連接池線程前綴、字符串池長度或名稱規(guī)則等
KeyedObjectPool<K,V>：鍵值對形式的對象池接口，使用場景很少
KeyedPooledObjectFactory<K,V>：同上，為鍵值對對象池管理對象的工廠
池對象的狀態(tài)
查看源碼PooledObjectState枚舉下列出了池對象所有可能處于的狀態(tài)。
public enum PooledObjectState {
? ? //在空閑隊列中,還未被使用
? ? IDLE,
? ? //使用中
? ? ALLOCATED,
? ? //在空閑隊列中,當前正在測試是否滿足被驅逐的條件
? ? EVICTION,
? ? ? //不在空閑隊列中，目前正在測試是否可能被驅逐。因為在測試過程中，試圖借用對象，并將其從隊列中刪除。
? ? //回收測試完成后，它應該被返回到隊列的頭部。
? ? EVICTION_RETURN_TO_HEAD,
? ? ? //在隊列中，正在被校驗
? ? VALIDATION,
? ? ? //不在隊列中，當前正在驗證。該對象在驗證時被借用，由于配置了testOnBorrow，
? ? //所以將其從隊列中刪除并預先分配。一旦驗證完成，就應該分配它。
? ? VALIDATION_PREALLOCATED,
? ? ? //不在隊列中，當前正在驗證。在之前測試是否將該對象從隊列中移除時，曾嘗試借用該對象。
? ? //一旦驗證完成，它應該被返回到隊列的頭部。
? ? VALIDATION_RETURN_TO_HEAD,
? ? ? //無效狀態(tài)(如驅逐測試或驗證)，并將/已被銷毀
? ? INVALID,
? ? ? //判定為無效,將會被設置為廢棄
? ? ABANDONED,
? ? ? //正在使用完畢,返回池中
? ? RETURNING
}
狀態(tài)理解
abandoned ：被借出后，長時間未被使用則被標記為該狀態(tài)。如代碼所示，當該對象處于ALLOCATED狀態(tài)，即被借出使用中，距離上次被使用的時間超過了設置的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配置判斷是否取用對象前執(zhí)行清理操作
再從idleObject中嘗試獲取對象，獲取不到就創(chuàng)建新的對象
判斷blockWhenExhausted是否設置為true，(這個配置的意思是當對象池的active狀態(tài)的對象數量已經達到最大值maxinum時是否進行阻塞直到有空閑對象)
是的話按照設置的borrowMaxWaitMillis屬性等待可用對象
有可用對象后調用工廠的factory.activateObject方法激活對象
當getTestOnBorrow設置為true時，調用factory.validateObject(p)對對象進行校驗，通過校驗后執(zhí)行下一步
調用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)即對象的激活和鈍化方法有什么用？
如圖在對象使用完被返回對象池時，如果校驗失敗直接銷毀，如果校驗通過需要先鈍化對象再存入空閑隊列。至于激活對象的方法在上述取用對象時也會先激活再被取出。
因此我們可以發(fā)現處于空閑和使用中的對象他們除了狀態(tài)不一致，我們也可以通過激活和鈍化的方式在他們之間增加新的差異，例如我們要做一個Elasticsearch連接池，每個對象就是一個帶有ip和端口的連接實例，很顯然訪問es集群是多個不同的ip，所以每次訪問的ip不一定相同，我們則可以在激活操作為對象賦值ip和端口，鈍化操作中將ip和端口歸為默認值或者空，這樣流程更為標準。
分享閱讀：Spring Boot 學習筆記。
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狀態(tài)，即可用實例為空時，是否阻塞來獲取實例的線程，默認true
fairness：當對象池處于exhausted狀態(tài)，即可用實例為空時，大量線程在同時阻塞等待獲取可用的實例，fairness配置來控制是否啟用公平鎖算法，即先到先得，默認為false。這一項的前提是blockWhenExhausted配置為true
maxWaitMillis：最大阻塞時間，當對象池處于exhausted狀態(tài)，即可用實例為空時，大量線程在同時阻塞等待獲取可用的實例，如果阻塞時間超過了maxWaitMillis將會拋出異常。當此值為負數時，代表無限期阻塞直到可用。默認為-1
testOnCreate：創(chuàng)建對象前是否校驗（即調用工廠的validateObject()方法），如果檢驗失敗，那么borrowObject()返回將失敗，默認為false
testOnBorrow：取用對象前是否檢驗，默認為false
testOnReturn：返回對象池前是否檢驗，即調用工廠的returnObject()，若檢驗失敗會銷毀對象而不是返回池中，默認為false
timeBetweenEvictionRunsMillis：驅逐周期，默認為-1代表不進行驅逐測試
testWhileIdle：處于idle隊列中即閑置的對象是否被驅逐器進行驅逐驗證，當該對象上次運行時間距當前超過了setTimeBetweenEvictionRunsMillis(long))設置的值，將會被驅逐驗證，調用validateObject()方法，若驗證成功，對象將會銷毀。默認為false
使用步驟
創(chuàng)建工廠類：通過繼承BaseGenericObjectPool或者實現基礎接口PooledObjectFactory,并按照業(yè)務需求重寫對象的創(chuàng)建、銷毀、校驗、激活、鈍化方法，其中銷毀多為連接的關閉、置空等。
創(chuàng)建池：通過繼承GenericObjectPool或者實現基礎接口ObjectPool，建議使用前者，它為我們提供了空閑對象驅逐檢測機制（即將空閑隊列中長時間未使用的對象銷毀，降低內存占用），以及提供了很多對象的基本信息，例如對象最后被使用的時間、使用對象前是否檢驗等。
創(chuàng)建池相關配置（可選）：通過繼承GenericObjectPoolConfig或者繼承BaseObjectPoolConfig，來增加對線程池的配置控制，建議使用前者，它為我們實現了基本方法，只需要自己添加需要的屬性即可。
創(chuàng)建包裝類（可選）：即要存在于對象池中的對象，在實際對象之外添加許多基礎屬性，便于了解對象池中對象的實時狀態(tài)。
注意事項
我們雖然使用了默認實現，但是也應該結合實際生產情況進行優(yōu)化，不能使用了線程池而性能卻更低了。另外，Java 系列面試題和答案全部整理好了，微信搜索Java技術棧，在后臺發(fā)送：面試，可以在線閱讀。
在使用中我們應注意以下事項：
要為對象池設置空閑隊列最大最小值，默認最大最小值，默認最大為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屬性，即取用對象最大等待時間
使用完對象及時釋放對象，將對象返回池中，特別是發(fā)生了異常也要通過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將會執(zhí)行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)方法，原因顯而易見，對象池對我們是否使用完了對象是無感知的，需要我們調用該方法回收對象，特別是發(fā)生異常也要保證回收，因此最佳實踐如下：
try{
? item = pool.borrowObject();
} catch(Exception e) {
? log.error("....");
} finally {
? pool.returnObject(item);
}
實例使用
實例1：實現一個簡單的字符串池
創(chuàng)建字符串工廠
推薦一個 Spring Boot 基礎教程及實戰(zhàn)示例：https://www.javastack.cn/categories/Spring-Boot/
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);
? ? }
}
創(chuàng)建字符串池
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，我們循環(huán)取用3次，并不釋放資源。另外，關注公眾號Java技術棧，在后臺回復：面試，可以獲取我整理的 Java 系列面試題和答案，非常齊全。
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
我們放開注釋，釋放資源后得到正常執(zhí)行結果
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-
