> 池塘裡養：Object；

# 一、設計與原理

## 1、基礎案例

首先看一個基於`common-pool2`物件池元件的應用案例，主要有工廠類、物件池、物件三個核心角色，以及池化物件的使用流程：

```java
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ObjPool {
    public static void main(String[] args) throws Exception {
        // 宣告物件池
        DevObjPool devObjPool = new DevObjPool() ;
        // 池中借用物件
        DevObj devObj = devObjPool.borrowObject();
        System.out.println("Idle="+devObjPool.getNumIdle()+"；Active="+devObjPool.getNumActive());
        // 使用物件
        devObj.devObjInfo();
        // 歸還給物件池
        devObjPool.returnObject(devObj);
        System.out.println("Idle="+devObjPool.getNumIdle()+"；Active="+devObjPool.getNumActive());
        // 檢視物件池
        System.out.println(devObjPool.listAllObjects());
    }
}
/**
 * 物件定義
 */
class DevObj {
    private static final Logger logger = LoggerFactory.getLogger(DevObj.class) ;
    public DevObj (){
        logger.info("build...dev...obj");
    }
    public void devObjInfo (){
        logger.info("dev...obj...info");
    }
}
/**
 * 物件工廠
 */
class DevObjFactory extends BasePooledObjectFactory<devobj> {
    @Override
    public DevObj create() throws Exception {
        // 建立物件
        return new DevObj() ;
    }
    @Override
    public PooledObject<devobj> wrap(DevObj devObj) {
        // 池化物件
        return new DefaultPooledObject<>(devObj);
    }
}
/**
 * 物件池
 */
class DevObjPool extends GenericObjectPool<devobj> {
    public DevObjPool() {
        super(new DevObjFactory(), new GenericObjectPoolConfig<>());
    }
}
```

案例中物件是完全自定義的；物件工廠中則重寫兩個核心方法：建立和包裝，以此建立池化物件；物件池的構建依賴定義的物件工廠，配置採用元件提供的常規配置類；可以透過調整物件例項化的時間以及建立物件的個數，初步理解物件池的原理。

## 2、介面設計

**1.1 PooledObjectFactory 介面**

- 工廠類，負責物件例項化，建立、驗證、銷燬、狀態管理等；
- 案例中`BasePooledObjectFactory類`則是該介面的基礎實現；

**1.2 ObjectPool 介面**

- 物件池，並且繼承`Closeable`介面，管理物件生命週期，以及活躍和空閒物件的資料資訊獲取；
- 案例中`GenericObjectPool類`是對於該介面的實現，並且是可配置化的方式；

**1.3 PooledObject 介面**

- 池化物件，基於包裝類被維護在物件池中，並且維護一些附加資訊用來跟蹤，例如時間、狀態；
- 案例中採用`DefaultPooledObject`包裝類，實現該介面並且執行緒安全，注意工廠類中的重寫；

## 3、執行原理

![](http://img.blog.itpub.net/blog/2022/04/05/e03dcbf5c789ca25.png?x-oss-process=style/bb)

透過物件池獲取物件，可能是透過工廠新建立的，也可能是空閒的物件；當物件獲取成功且使用完成後，需要歸還物件；在案例執行過程中，不斷查詢物件池中空閒和活躍物件的數量，用來監控池的變化。

# 二、構造分析

## 1、物件池

```java
public GenericObjectPool(final PooledObjectFactory<t> factory,final GenericObjectPoolConfig<t> config);
```

在完整的構造方法中，涉及到三個核心物件：工廠物件、配置物件、雙端阻塞佇列；透過這幾個物件建立一個新的物件池；在config中提供了一些簡單的預設配置：例如maxTotal、maxIdle、minIdle等，也可以擴充套件自定義配置；

## 2、雙端佇列

```java
private final LinkedBlockingDeque<pooledobject>> idleObjects;
public GenericObjectPool(final PooledObjectFactory<t> factory,final GenericObjectPoolConfig<t> config) {
    idleObjects = new LinkedBlockingDeque<>(config.getFairness());
}
```

LinkedBlockingDeque支援在佇列的首尾操作元素，例如新增和移除等；操作需要透過主鎖進行加鎖，並且基於兩個狀態鎖進行協作；

```java
// 隊首節點
private transient LinkedBlockingDeque.Node<e> first;
// 隊尾節點
private transient LinkedBlockingDeque.Node<e> last;
// 主鎖
private final InterruptibleReentrantLock lock;
// 非空狀態鎖
private final Condition notEmpty;
// 未滿狀態鎖
private final Condition notFull;
```

關於連結串列和佇列的特點，在之前的文章中有單獨分析過，此處的原始碼在JDK的容器中也很常見，這裡不在贅述，物件池的整個構造有大致輪廓之後，下面再來細看物件的管理邏輯。

# 三、物件管理

## 1、新增物件

建立一個新物件並且放入池中，通常應用在需要**預載入**的場景中；涉及到兩個核心操作：工廠建立物件，物件池化管理；

```java
public void GenericObjectPool.addObject() throws Exception ;
```

## 2、借用物件

```java
public T GenericObjectPool.borrowObject(final long borrowMaxWaitMillis) throws Exception ;
```

![](http://img.blog.itpub.net/blog/2022/04/05/8d026977f7356309.png?x-oss-process=style/bb)

首先從佇列中獲取物件；如果沒有獲取到，呼叫工廠建立方法，之後池化管理；物件獲取之後會改變狀態為`ALLOCATED`使用中；最後經過工廠的確認，完成物件獲取動作；

## 3、歸還物件

```java
public void GenericObjectPool.returnObject(final T obj) ；
```

![](http://img.blog.itpub.net/blog/2022/04/05/25d3c182db736ba0.png?x-oss-process=style/bb)

歸還物件的時候，首先轉換為池化物件和標記`RETURNING`狀態；經過多次校驗判斷，如果失敗則銷燬該物件，並重新維護物件池中可用的空閒物件；最終物件被標記為空閒狀態，如果不超出最大空閒數，則物件被放到佇列的某一端；

## 4、物件狀態

關於池化物件的狀態在`PooledObjectState`類中有列舉和描述，在圖中只是對部分幾個狀態流轉做示意，更多細節可以參考狀態類；

![](http://img.blog.itpub.net/blog/2022/04/05/e42693d449ae7b4f.png?x-oss-process=style/bb)

可以參考在上述案例中使用到的`DefaultPooledObject`預設池化物件類中相關方法，結合狀態列舉，可以理解不同狀態之間的校驗和轉換。

# 四、Redis應用

Lettuce作為Redis高階的客戶端元件，通訊層使用Netty元件，並且是執行緒安全，支援同步和非同步模式，支援叢集和哨兵模式；作為當下專案中常用的配置，其底層物件池基於`common-pool2`元件。

## 1、配置管理

基於如下配置即表示採用Lettuce元件，其中涉及到池的幾個引數配置：最小空閒、最大活躍、最大空閒；這裡可以對比GenericObjectPoolConfig中的配置：

```yaml
spring:
  redis:
    host: ${REDIS_HOST:127.0.0.1}
    lettuce:
      pool:
        min-idle: 10
        max-active: 100
        max-idle: 100
```

## 2、原始碼分析

圍繞物件池的特點，自然去追尋原始碼中關於：配置、工廠、物件幾個核心的角色類；從上述配置引數切入，可以很容易發現如下幾個類：

![](http://img.blog.itpub.net/blog/2022/04/05/f4a716ff2a2d7c80.png?x-oss-process=style/bb)

**2.1 配置轉換**

```java
// 連線配置
class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
    private static class PoolBuilderFactory {
        // 構建物件池配置
        private GenericObjectPoolConfig> getPoolConfig(RedisProperties.Pool properties) {
            GenericObjectPoolConfig> config = new GenericObjectPoolConfig<>();
            config.setMaxTotal(properties.getMaxActive());
            config.setMaxIdle(properties.getMaxIdle());
            config.setMinIdle(properties.getMinIdle());
            return config;
        }
    }
}
```

這裡將配置檔案中Redis的相關引數，構建到GenericObjectPoolConfig類中，即配置載入過程；

**2.2 物件池構造**

```java
class LettucePoolingConnectionProvider implements LettuceConnectionProvider {
    // 物件池核心角色
    private final GenericObjectPoolConfig poolConfig;
    private final BoundedPoolConfig asyncPoolConfig;
    private final Map<class>, GenericObjectPool> pools = new ConcurrentHashMap(32);
    LettucePoolingConnectionProvider(LettuceConnectionProvider provider, LettucePoolingClientConfiguration config) {
        this.poolConfig = clientConfiguration.getPoolConfig();
        this.asyncPoolConfig = CommonsPool2ConfigConverter.bounded(this.config);
    }
}
```

在構造方法中獲取物件池的配置資訊，這裡並沒有直接例項化池物件，而是採用ConcurrentHashMap容器來動態維護；

**2.3 物件管理**

```java
class LettucePoolingConnectionProvider implements LettuceConnectionProvider {
    // 獲取Redis連線
    public <t extends="" statefulconnection="">> T getConnection(Class<t> connectionType) {
        GenericObjectPool pool = (GenericObjectPool)this.pools.computeIfAbsent();
        StatefulConnection, ?> connection = (StatefulConnection)pool.borrowObject();
    }
    // 釋放Redis連線
    public void release(StatefulConnection, ?> connection) {
        GenericObjectPool<statefulconnection>> pool = (GenericObjectPool)this.poolRef.remove(connection);
    }
}
```

在獲取池物件時，如果不存在則根據相關配置建立池物件，並維護到Map容器中，然後從池中借用Redis連線物件；釋放物件時首先判斷物件所屬的池，將物件歸還到相應的池中。

**最後總結**，本文從物件池的一個簡單案例切入，主要分析`common-pool2`元件關於：池、工廠、配置、物件管理幾個角色的原始碼邏輯，並且參考其在Redis中的實踐，只是冰山一角，像這種通用型並且應用範圍廣的元件，很值得時常去讀一讀原始碼，真的令人驚歎其鬼斧天工的設計。

# 五、參考原始碼

```
應用倉庫：
https://gitee.com/cicadasmile/butte-flyer-parent

元件封裝：
https://gitee.com/cicadasmile/butte-frame-parent
```

![](http://img.blog.itpub.net/blog/2022/04/05/36bb0089e63d5015.png?x-oss-process=style/bb)</statefulconnection></t></t></class></e></e></t></t></pooledobject></t></t></devobj></devobj></devobj>

基於Apache元件，分析物件池原理

相關文章