Java 中對象池的本質是什麼？（實戰分析版）

簡介

對象池顧名思義就是存放對象的池，與我們常聽到的線程池、數據庫連接池、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. 對象真實是存儲在哪裏？

 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

使用步驟

1. 創建工廠類：通過繼承BaseGenericObjectPool或者實現基礎接口PooledObjectFactory, 並按照業務需求重寫對象的創建、銷燬、校驗、激活、鈍化方法，其中銷燬多爲連接的關閉、置空等。

2. 創建池：通過繼承GenericObjectPool或者實現基礎接口ObjectPool，建議使用前者，它爲我們提供了空閒對象驅逐檢測機制（即將空閒隊列中長時間未使用的對象銷燬，降低內存佔用），以及提供了很多對象的基本信息，例如對象最後被使用的時間、使用對象前是否檢驗等。

3. 創建池相關配置（可選）：通過繼承GenericObjectPoolConfig或者繼承BaseObjectPoolConfig，來增加對線程池的配置控制，建議使用前者，它爲我們實現了基本方法，只需要自己添加需要的屬性即可。

4. 創建包裝類（可選）：即要存在於對象池中的對象，在實際對象之外添加許多基礎屬性，便於瞭解對象池中對象的實時狀態。

注意事項

我們雖然使用了默認實現，但是也應該結合實際生產情況進行優化，不能使用了線程池而性能卻更低了。在使用中我們應注意以下事項：

• 要爲對象池設置空閒隊列最大最小值，默認最大最小值，默認最大爲 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-

全部代碼地址

https://github.com/Motianshi/alldemo/tree/master/demo-pool2

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/PiLc-pvLzd_CsedThDGTPw