面試官：什么是物件池？有什么用？別說你還不會！-有解無憂

作者：Hai Xiang
來自：https://www.cnblogs.com/haixiang/p/14783955.html

物件池顧名思義就是存放物件的池，與我們常聽到的執行緒池、資料庫連接池、http連接池等一樣，都是典型的池化設計思想，

物件池的優點就是可以集中管理池中物件，減少頻繁創建和銷毀長期使用的物件，從而提升復用性，以節約資源的消耗，可以有效避免頻繁為物件分配記憶體和釋放堆中記憶體，進而減輕jvm垃圾收集器的負擔，避免記憶體抖動，

Apache Common Pool2 是Apache提供的一個通用物件池技術實作，可以方便定制化自己需要的物件池，大名鼎鼎的 Redis 客戶端 Jedis 內部連接池就是基于它來實作的，

核心介面

Apache Common Pool2 的核心內部類如下：

ObjectPool：物件池介面，物件池物體，取用物件的地方
- 物件的提供與歸還(工廠來操作)：borrowObject returnObject
- 創建物件(使用工廠來創建)：addObject
- 銷毀物件(使用工廠來銷毀)：invalidateObject
- 池中空閑物件數量、被使用物件數量：getNumActive getNumIdle
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.物件真實是存盤在哪里？

```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<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-

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2021最新版)

2.別在再滿屏的 if/ else 了，試試策略模式，真香！！

3.臥槽！Java 中的 xx ≠ null 是什么新語法？

4.Spring Boot 2.5 重磅發布，黑暗模式太炸了！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/319570.html

標籤：Java

上一篇：SpringBoot實作檔案在線預覽

下一篇：一個簡單的超市訂單管理系統（2）-準備作業階段結束