使用Jakarta Commons Pool處理對(duì)象池化

2019-11-18 15:14:01

字體：大中小

供稿：網(wǎng)友

內(nèi)容：

對(duì)象池化技術(shù)
Jakarta Commons Pool組件
下載和安裝
PoolableObjectFactory、ObjectPool和ObjectPoolFactory
創(chuàng)立PoolableObjectFactory
使用ObjectPool
利用ObjectPoolFactory
借助BasePoolableObjectFactory
各式各樣的ObjectPool
StackObjectPool
SoftReferenceObjectPool
GenericObjectPool
GenericObjectPool.Config
帶鍵值的對(duì)象池
當(dāng)出借少于歸還
線程安全問題
什么時(shí)候不要池化
結(jié)束語(yǔ)
參考資料
關(guān)于作者
對(duì)于本文的評(píng)價(jià)

孫海濤 (alexhsun@hotmail.com)

2003 年 12 月

恰當(dāng)?shù)厥褂脤?duì)象池化技術(shù)，可以有效地減少對(duì)象生成和初始化時(shí)的消耗，提高系統(tǒng)的運(yùn)行效率。Jakarta Commons Pool組件提供了一整套用于實(shí)現(xiàn)對(duì)象池化的框架，以及若干種各具特色的對(duì)象池實(shí)現(xiàn)，可以有效地減少處理對(duì)象池化時(shí)的工作量，為其它重要的工作留下更多的精力和時(shí)間。
創(chuàng)建新的對(duì)象并初始化的操作，可能會(huì)消耗很多的時(shí)間。在這種對(duì)象的初始化工作包含了一些費(fèi)時(shí)的操作（例如，從一臺(tái)位于20,000千米以外的主機(jī)上讀出一些數(shù)據(jù)）的時(shí)候，尤其是這樣。在需要大量生成這樣的對(duì)象的時(shí)候，就可能會(huì)對(duì)性能造成一些不可忽略的影響。要緩解這個(gè)問題，除了選用更好的硬件和更棒的虛擬機(jī)以外，適當(dāng)?shù)夭捎靡恍┠軌驕p少對(duì)象創(chuàng)建次數(shù)的編碼技巧，也是一種有效的對(duì)策。對(duì)象池化技術(shù)（Object Pooling）就是這方面的聞名技巧，而Jakarta Commons Pool組件則是處理對(duì)象池化的得力外援。

對(duì)象池化技術(shù)
對(duì)象池化的基本思路是：將用過的對(duì)象保存起來，等下一次需要這種對(duì)象的時(shí)候，再拿出來重復(fù)使用，從而在一定程度上減少頻繁創(chuàng)建對(duì)象所造成的開銷。用于充當(dāng)保存對(duì)象的“容器”的對(duì)象，被稱為“對(duì)象池”（Object Pool，或簡(jiǎn)稱Pool）。

對(duì)于沒有狀態(tài)的對(duì)象（例如String），在重復(fù)使用之前，無(wú)需進(jìn)行任何處理；對(duì)于有狀態(tài)的對(duì)象（例如StringBuffer），在重復(fù)使用之前，就需要把它們恢復(fù)到等同于剛剛生成時(shí)的狀態(tài)。由于條件的限制，恢復(fù)某個(gè)對(duì)象的狀態(tài)的操作不可能實(shí)現(xiàn)了的話，就得把這個(gè)對(duì)象拋棄，改用新創(chuàng)建的實(shí)例了。

并非所有對(duì)象都適合拿來池化??因?yàn)榫S護(hù)對(duì)象池也要造成一定開銷。對(duì)生成時(shí)開銷不大的對(duì)象進(jìn)行池化，反而可能會(huì)出現(xiàn)“維護(hù)對(duì)象池的開銷”大于“生成新對(duì)象的開銷”，從而使性能降低的情況。但是對(duì)于生成時(shí)開銷可觀的對(duì)象，池化技術(shù)就是提高性能的有效策略了。

說明：英語(yǔ)中的Pool除了“池”之外，還有“供多方共享的資源”意思。作者十分懷疑第二種才是“Object Pool”中的Pool的實(shí)際含義，但是“對(duì)象池”的說法已經(jīng)廣為流傳，而一時(shí)又沒有足以替代的貼切譯法，因此這里仍然沿用這種譯名。
Jakarta Commons Pool組件

Jakarta Commons Pool是一個(gè)用于在java程序中實(shí)現(xiàn)對(duì)象池化的組件。它的基本情況是：

主要作者：Morgan Delagrange、Geir Magnusson、Craig McClanahan、Rodney Waldhoff、David Weinrich和Dirk Verbeeck

最新版本：1.1

所含包數(shù)：2個(gè)（org.apache.commons.pool和org.apache.commons.pool.impl）

所含類數(shù)：21個(gè)（其中有4個(gè)抽象類和6個(gè)接口）

適用平臺(tái)：Java 2, Standard Edition.

單純地使用Pool組件不需要太多的Java 2的知識(shí)和經(jīng)驗(yàn)，對(duì)語(yǔ)法和基本概念（對(duì)象、異常、類、接口、實(shí)例、繼續(xù)和實(shí)現(xiàn)等）有一般了解即可。

下載和安裝
為了順利的按照本文中提到的方法使用Pool組件，除去Java 2 SDK外，還需要先預(yù)備下列一些東西：

Jakarta Commons Pool

所需版本：1.0.1+
下載地址： http://jakarta.apache.org/commons/pool
作用：處理對(duì)象池化
Jakarta Commons Collections

所需版本：2.1+
下載地址： http://jakarta.apache.org/commons/collections
作用：支持Jakarta Commons Pool的運(yùn)行
以上兩種軟件均有已編譯包和源代碼包兩種形式可供選擇。一般情況下，使用已編譯包即可。不過建議同時(shí)也下載源代碼包，作為參考資料使用。

假如打算使用源代碼包自行編譯，那么還需要預(yù)備以下一些東西：

Ant

所需版本：1.5.3+
下載地址： http://ant.apache.org
作用：運(yùn)行編譯用腳本
JUnit

所需版本：3.8.1+
下載地址： http://www.junit.org
作用：編譯和運(yùn)行單元測(cè)試
具體的編譯方法，可以參看有關(guān)的Ant文檔。

將解壓或編譯后得到的commons-pool.jar和commons-collections.jar放入CLASSPATH，就可以開始使用Pool組件了。

PoolableObjectFactory、ObjectPool和ObjectPoolFactory
在Pool組件中，對(duì)象池化的工作被劃分給了三類對(duì)象：

PoolableObjectFactory用于治理被池化的對(duì)象的產(chǎn)生、激活、掛起、校驗(yàn)和銷毀；

ObjectPool用于治理要被池化的對(duì)象的借出和歸還，并通知PoolableObjectFactory完成相應(yīng)的工作；

ObjectPoolFactory則用于大量生成相同類型和設(shè)置的ObjectPool。

相應(yīng)地，使用Pool組件的過程，也大體可以劃分成“創(chuàng)立PoolableObjectFactory”、“使用ObjectPool”和可選的“利用ObjectPoolFactory”三種動(dòng)作。

創(chuàng)立PoolableObjectFactory
Pool組件利用PoolableObjectFactory來照看被池化的對(duì)象。ObjectPool的實(shí)例在需要處理被池化的對(duì)象的產(chǎn)生、激活、掛起、校驗(yàn)和銷毀工作時(shí)，就會(huì)調(diào)用跟它關(guān)聯(lián)在一起的PoolableObjectFactory實(shí)例的相應(yīng)方法來操作。

PoolableObjectFactory是在org.apache.commons.pool包中定義的一個(gè)接口。實(shí)際使用的時(shí)候需要利用這個(gè)接口的一個(gè)具體實(shí)現(xiàn)。Pool組件本身沒有包含任何一種PoolableObjectFactory實(shí)現(xiàn)，需要根據(jù)情況自行創(chuàng)立。

創(chuàng)立PoolableObjectFactory的大體步驟是：

創(chuàng)建一個(gè)實(shí)現(xiàn)了PoolableObjectFactory接口的類。

import org.apache.commons.pool.PoolableObjectFactory;

public class PoolableObjectFactorySample
implements PoolableObjectFactory {
PRivate static int counter = 0;
}

為這個(gè)類添加一個(gè)Object makeObject()方法。這個(gè)方法用于在必要時(shí)產(chǎn)生新的對(duì)象。

public Object makeObject() throws Exception {
Object obj = String.valueOf(counter++);
System.err.println("Making Object " + obj);
return obj;
}

為這個(gè)類添加一個(gè)void activateObject(Object obj)方法。這個(gè)方法用于將對(duì)象“激活”??設(shè)置為適合開始使用的狀態(tài)。

public void activateObject(Object obj) throws Exception {
System.err.println("Activating Object " + obj);
}

為這個(gè)類添加一個(gè)void passivateObject(Object obj)方法。這個(gè)方法用于將對(duì)象“掛起”??設(shè)置為適合開始休眠的狀態(tài)。

public void passivateObject(Object obj) throws Exception {
System.err.println("Passivating Object " + obj);
}

為這個(gè)類添加一個(gè)boolean validateObject(Object obj)方法。這個(gè)方法用于校驗(yàn)一個(gè)具體的對(duì)象是否仍然有效，已失效的對(duì)象會(huì)被自動(dòng)交給destroyObject方法銷毀

public boolean validateObject(Object obj) {
boolean result = (Math.random() > 0.5);
System.err.println("Validating Object "
+ obj + " : " + result);
return result;
}

為這個(gè)類添加一個(gè)void destroyObject(Object obj)方法。這個(gè)方法用于銷毀被validateObject判定為已失效的對(duì)象。

public void destroyObject(Object obj) throws Exception {
System.err.println("Destroying Object " + obj);
}

最后完成的PoolableObjectFactory類似這個(gè)樣子：

PoolableObjectFactorySample.java

import org.apache.commons.pool.PoolableObjectFactory;

public class PoolableObjectFactorySample
implements PoolableObjectFactory {
private static int counter = 0;

public Object makeObject() throws Exception {
Object obj = String.valueOf(counter++);
System.err.println("Making Object " + obj);
return obj;
}

public void activateObject(Object obj) throws Exception {
System.err.println("Activating Object " + obj);
}

public void passivateObject(Object obj) throws Exception {
System.err.println("Passivating Object " + obj);
}

public boolean validateObject(Object obj) {
/* 以1/2的概率將對(duì)象判定為失效 */
boolean result = (Math.random() > 0.5);
System.err.println("Validating Object "
+ obj + " : " + result);
return result;
}

public void destroyObject(Object obj) throws Exception {
System.err.println("Destroying Object " + obj);
}
}

使用ObjectPool
有了合適的PoolableObjectFactory之后，便可以開始請(qǐng)出ObjectPool來與之同臺(tái)演出了。

ObjectPool是在org.apache.commons.pool包中定義的一個(gè)接口，實(shí)際使用的時(shí)候也需要利用這個(gè)接口的一個(gè)具體實(shí)現(xiàn)。Pool組件本身包含了若干種現(xiàn)成的ObjectPool實(shí)現(xiàn)，可以直接利用。假如都不合用，也可以根據(jù)情況自行創(chuàng)建。具體的創(chuàng)建方法，可以參看Pool組件的文檔和源碼。

ObjectPool的使用方法類似這樣：

生成一個(gè)要用的PoolableObjectFactory類的實(shí)例。

PoolableObjectFactory factory = new PoolableObjectFactorySample();

利用這個(gè)PoolableObjectFactory實(shí)例為參數(shù)，生成一個(gè)實(shí)現(xiàn)了ObjectPool接口的類（例如StackObjectPool）的實(shí)例，作為對(duì)象池。

ObjectPool pool = new StackObjectPool(factory);

需要從對(duì)象池中取出對(duì)象時(shí)，調(diào)用該對(duì)象池的Object borrowObject()方法。

Object obj = null;
obj = pool.borrowObject();

需要將對(duì)象放回對(duì)象池中時(shí)，調(diào)用該對(duì)象池的void returnObject(Object obj)方法。

pool.returnObject(obj);

當(dāng)不再需要使用一個(gè)對(duì)象池時(shí)，調(diào)用該對(duì)象池的void close()方法，釋放它所占據(jù)的資源。

pool.close();

這些操作都可能會(huì)拋出異常，需要另外處理。

比較完整的使用ObjectPool的全過程，可以參考這段代碼：

ObjectPoolSample.java

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.StackObjectPool;

public class ObjectPoolSample {

public static void main(String[] args) {
Object obj = null;
PoolableObjectFactory factory
= new PoolableObjectFactorySample();
ObjectPool pool = new StackObjectPool(factory);
try {
for(long i = 0; i < 100 ; i++) {
System.out.println("== " + i + " ==");
obj = pool.borrowObject();
System.out.println(obj);
pool.returnObject(obj);
}
obj = null;//明確地設(shè)為null，作為對(duì)象已歸還的標(biāo)志
}
catch (Exception e) {
e.printStackTrace();
}
finally {
try{
if (obj != null) {//避免將一個(gè)對(duì)象歸還兩次
pool.returnObject(obj);
}
pool.close();
}
catch (Exception e){
e.printStackTrace();
}
}
}
}

另外，ObjectPool接口還定義了幾個(gè)可以由具體的實(shí)現(xiàn)決定要不要支持的操作，包括：

void clear()

清除所有當(dāng)前在此對(duì)象池中休眠的對(duì)象。

int getNumActive()

返回已經(jīng)從此對(duì)象池中借出的對(duì)象的總數(shù)。

int getNumIdle()

返回當(dāng)前在此對(duì)象池中休眠的對(duì)象的數(shù)目。

void setFactory(PoolableObjectFactory factory)

將當(dāng)前對(duì)象池與參數(shù)中給定的PoolableObjectFactory相關(guān)聯(lián)。假如在當(dāng)前狀態(tài)下，無(wú)法完成這一操作，會(huì)有一個(gè)IllegalStateException異常拋出。

假如所用的ObjectPool實(shí)現(xiàn)不支持這些操作，那么調(diào)用這些方法的時(shí)候，會(huì)拋出一個(gè)UnsupportedOperationException異常。
利用ObjectPoolFactory
有時(shí)候，要在多處生成類型和設(shè)置都相同的ObjectPool。假如在每個(gè)地方都重寫一次調(diào)用相應(yīng)構(gòu)造方法的代碼，不但比較麻煩，而且日后修改起來，也有所不便。這種時(shí)候，正是使用ObjectPoolFactory的時(shí)機(jī)。

ObjectPoolFactory是一個(gè)在org.apache.commons.pool中定義的接口，它定義了一個(gè)稱為ObjectPool createPool()方法，可以用于大量生產(chǎn)類型和設(shè)置都相同的ObjectPool。

Pool組件中，對(duì)每一個(gè)ObjectPool實(shí)現(xiàn)，都有一個(gè)對(duì)應(yīng)的ObjectPoolFactory實(shí)現(xiàn)。它們相互之間，有一一對(duì)應(yīng)的參數(shù)相同的構(gòu)造方法。使用的時(shí)候，只要先用想要的參數(shù)和想用的ObjectPoolFactory實(shí)例，構(gòu)造出一個(gè)ObjectPoolFactory對(duì)象，然后在需要生成ObjectPool的地方，調(diào)用這個(gè)對(duì)象的createPool()方法就可以了。日后無(wú)論想要調(diào)整所用ObjectPool的參數(shù)還是類型，只需要修改這一處，就可以大功告成了。

將《使用ObjectPool》一節(jié)中的例子，改為使用ObjectPoolFactory來生成所用的ObjectPool對(duì)象之后，基本就是這種形式：

ObjectPoolFactorySample.java

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.ObjectPoolFactory;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.StackObjectPoolFactory;

public class ObjectPoolFactorySample {

public static void main(String[] args) {
Object obj = null;
PoolableObjectFactory factory
= new PoolableObjectFactorySample();
ObjectPoolFactory poolFactory
= new StackObjectPoolFactory(factory);
ObjectPool pool = poolFactory.createPool();
try {
for(long i = 0; i < 100 ; i++) {
System.out.println("== " + i + " ==");
obj = pool.borrowObject();
System.out.println(obj);
pool.returnObject(obj);
}
obj = null;
}
catch (Exception e) {
e.printStackTrace();
}
finally {
try{
if (obj != null) {
pool.returnObject(obj);
}
pool.close();
}
catch (Exception e){
e.printStackTrace();
}
}
}
}

借助BasePoolableObjectFactory
PoolableObjectFactory定義了許多方法，可以適應(yīng)多種不同的情況。但是，在并沒有什么非凡需要的時(shí)候，直接實(shí)現(xiàn)PoolableObjectFactory接口，就要編寫若干的不進(jìn)行任何操作，或是始終返回true的方法來讓編譯通過，比較繁瑣。這種時(shí)候就可以借助BasePoolableObjectFactory的威力，來簡(jiǎn)化編碼的工作。

BasePoolableObjectFactory是org.apache.commons.pool包中的一個(gè)抽象類。它實(shí)現(xiàn)了PoolableObjectFactory接口，并且為除了makeObject之外的方法提供了一個(gè)基本的實(shí)現(xiàn)??activateObject、passivateObject和destroyObject不進(jìn)行任何操作，而validateObject始終返回true。通過繼續(xù)這個(gè)類，而不是直接實(shí)現(xiàn)PoolableObjectFactory接口，就可以免去編寫一些只起到讓編譯通過的作用的代碼的麻煩了。

這個(gè)例子展示了一個(gè)從BasePoolableObjectFactory擴(kuò)展而來的PoolableObjectFactory：

BasePoolableObjectFactorySample.java

import org.apache.commons.pool.BasePoolableObjectFactory;

public class BasePoolableObjectFactorySample
extends BasePoolableObjectFactory {

private int counter = 0;

public Object makeObject() throws Exception {
return String.valueOf(counter++);
}
}

各式各樣的ObjectPool
可口可樂公司的軟飲料有可口可樂、雪碧和芬達(dá)等品種，百事可樂公司的軟飲料有百事可樂、七喜和美年達(dá)等類型，而Pool組件提供的ObjectPool實(shí)現(xiàn)則有StackObjectPool、SoftReferenceObjectPool和GenericObjectPool等種類。

不同類型的軟飲料各有各自的特點(diǎn)，分別適應(yīng)不同消費(fèi)者的口味；而不同類型的ObjectPool也各有各自的特色，分別適應(yīng)不同的情況。

StackObjectPool
StackObjectPool利用一個(gè)java.util.Stack對(duì)象來保存對(duì)象池里的對(duì)象。這種對(duì)象池的特色是：

可以為對(duì)象池指定一個(gè)初始的參考大小（當(dāng)空間不夠時(shí)會(huì)自動(dòng)增長(zhǎng)）。
在對(duì)象池已空的時(shí)候，調(diào)用它的borrowObject方法，會(huì)自動(dòng)返回新創(chuàng)建的實(shí)例。
可以為對(duì)象池指定一個(gè)可保存的對(duì)象數(shù)目的上限。達(dá)到這個(gè)上限之后，再向池里送回的對(duì)象會(huì)被自動(dòng)送去回收。
StackObjectPool的構(gòu)造方法共有六個(gè)，其中：

最簡(jiǎn)單的一個(gè)是StackObjectPool()，一切采用默認(rèn)的設(shè)置，也不指明要用的PoolableObjectFactory實(shí)例。
最復(fù)雜的一個(gè)則是StackObjectPool(PoolableObjectFactory factory, int max, int init)。其中：

參數(shù)factory指明要與之配合使用的PoolableObjectFactory實(shí)例；
參數(shù)max設(shè)定可保存對(duì)象數(shù)目的上限；
參數(shù)init則指明初始的參考大小。
剩余的四個(gè)構(gòu)造方法則是最復(fù)雜的構(gòu)造方法在某方面的簡(jiǎn)化版本，可以根據(jù)需要選用。它們是：

StackObjectPool(int max)
StackObjectPool(int max, int init)
StackObjectPool(PoolableObjectFactory factory)
StackObjectPool(PoolableObjectFactory factory, int max)
用不帶factory參數(shù)的構(gòu)造方法構(gòu)造的StackObjectPool實(shí)例，必須要在用它的setFactory(PoolableObjectFactory factory)方法與某一PoolableObjectFactory實(shí)例關(guān)聯(lián)起來后才能正常使用。

這種對(duì)象池可以在沒有Jakarta Commmons Collections組件支持的情況下正常運(yùn)行。

SoftReferenceObjectPool
SoftReferenceObjectPool利用一個(gè)java.util.ArrayList對(duì)象來保存對(duì)象池里的對(duì)象。不過它并不在對(duì)象池里直接保存對(duì)象本身，而是保存它們的“軟引用”（Soft Reference）。這種對(duì)象池的特色是：

可以保存任意多個(gè)對(duì)象，不會(huì)有容量已滿的情況發(fā)生。
在對(duì)象池已空的時(shí)候，調(diào)用它的borrowObject方法，會(huì)自動(dòng)返回新創(chuàng)建的實(shí)例。
可以在初始化同時(shí)，在池內(nèi)預(yù)先創(chuàng)建一定量的對(duì)象。
當(dāng)內(nèi)存不足的時(shí)候，池中的對(duì)象可以被Java虛擬機(jī)回收。
SoftReferenceObjectPool的構(gòu)造方法共有三個(gè)，其中：

最簡(jiǎn)單的是SoftReferenceObjectPool()，不預(yù)先在池內(nèi)創(chuàng)建對(duì)象，也不指明要用的PoolableObjectFactory實(shí)例。
最復(fù)雜的一個(gè)則是SoftReferenceObjectPool(PoolableObjectFactory factory, int initSize)。其中：

參數(shù)factory指明要與之配合使用的PoolableObjectFactory實(shí)例
參數(shù)initSize則指明初始化時(shí)在池中創(chuàng)建多少個(gè)對(duì)象。
剩下的一個(gè)構(gòu)造方法，則是最復(fù)雜的構(gòu)造方法在某方面的簡(jiǎn)化版本，適合在大多數(shù)情況下使用。它是：

SoftReferenceObjectPool(PoolableObjectFactory factory)
用不帶factory參數(shù)的構(gòu)造方法構(gòu)造的SoftReferenceObjectPool實(shí)例，也要在用它的setFactory(PoolableObjectFactory factory)方法與某一PoolableObjectFactory實(shí)例關(guān)聯(lián)起來后才能正常使用。

這種對(duì)象池也可以在沒有Jakarta Commmons Collections組件支持的情況下正常運(yùn)行。

GenericObjectPool
GenericObjectPool利用一個(gè)org.apache.commons.collections.CursorableLinkedList對(duì)象來保存對(duì)象池里的對(duì)象。這種對(duì)象池的特色是：

可以設(shè)定最多能從池中借出多少個(gè)對(duì)象。
可以設(shè)定池中最多能保存多少個(gè)對(duì)象。
可以設(shè)定在池中已無(wú)對(duì)象可借的情況下，調(diào)用它的borrowObject方法時(shí)的行為，是等待、創(chuàng)建新的實(shí)例還是拋出異常。
可以分別設(shè)定對(duì)象借出和還回時(shí)，是否進(jìn)行有效性檢查。
可以設(shè)定是否使用一個(gè)單獨(dú)的線程，對(duì)池內(nèi)對(duì)象進(jìn)行后臺(tái)清理。
GenericObjectPool的構(gòu)造方法共有七個(gè)，其中：

最簡(jiǎn)單的一個(gè)是GenericObjectPool(PoolableObjectFactory factory)。僅僅指明要用的PoolableObjectFactory實(shí)例，其它參數(shù)則采用默認(rèn)值。
最復(fù)雜的一個(gè)是GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)。其中：

參數(shù)factory指明要與之配合使用的PoolableObjectFactory實(shí)例。
參數(shù)maxActive指明能從池中借出的對(duì)象的最大數(shù)目。假如這個(gè)值不是正數(shù)，表示沒有限制。
參數(shù)whenExhaustedAction指定在池中借出對(duì)象的數(shù)目已達(dá)極限的情況下，調(diào)用它的borrowObject方法時(shí)的行為。可以選用的值有：
GenericObjectPool.WHEN_EXHAUSTED_BLOCK，表示等待；
GenericObjectPool.WHEN_EXHAUSTED_GROW，表示創(chuàng)建新的實(shí)例（不過這就使maxActive參數(shù)失去了意義）；
GenericObjectPool.WHEN_EXHAUSTED_FAIL，表示拋出一個(gè)java.util.NoSUChElementException異常。
參數(shù)maxWait指明若在對(duì)象池空時(shí)調(diào)用borrowObject方法的行為被設(shè)定成等待，最多等待多少毫秒。假如等待時(shí)間超過了這個(gè)數(shù)值，則會(huì)拋出一個(gè)java.util.NoSuchElementException異常。假如這個(gè)值不是正數(shù)，表示無(wú)限期等待。
參數(shù)testOnBorrow設(shè)定在借出對(duì)象時(shí)是否進(jìn)行有效性檢查。
參數(shù)testOnBorrow設(shè)定在還回對(duì)象時(shí)是否進(jìn)行有效性檢查。
參數(shù)timeBetweenEvictionRunsMillis，設(shè)定間隔每過多少毫秒進(jìn)行一次后臺(tái)對(duì)象清理的行動(dòng)。假如這個(gè)值不是正數(shù)，則實(shí)際上不會(huì)進(jìn)行后臺(tái)對(duì)象清理。
參數(shù)numTestsPerEvictionRun，設(shè)定在進(jìn)行后臺(tái)對(duì)象清理時(shí)，每次檢查幾個(gè)對(duì)象。假如這個(gè)值不是正數(shù)，則每次檢查的對(duì)象數(shù)是檢查時(shí)池內(nèi)對(duì)象的總數(shù)乘以這個(gè)值的負(fù)倒數(shù)再向上取整的結(jié)果??也就是說，假如這個(gè)值是-2（-3、-4、-5……）的話，那么每次大約檢查當(dāng)時(shí)池內(nèi)對(duì)象總數(shù)的1/2（1/3、1/4、1/5……）左右。
參數(shù)minEvictableIdleTimeMillis，設(shè)定在進(jìn)行后臺(tái)對(duì)象清理時(shí)，視休眠時(shí)間超過了多少毫秒的對(duì)象為過期。過期的對(duì)象將被回收。假如這個(gè)值不是正數(shù)，那么對(duì)休眠時(shí)間沒有非凡的約束。
參數(shù)testWhileIdle，則設(shè)定在進(jìn)行后臺(tái)對(duì)象清理時(shí)，是否還對(duì)沒有過期的池內(nèi)對(duì)象進(jìn)行有效性檢查。不能通過有效性檢查的對(duì)象也將被回收。
另一個(gè)比較非凡的構(gòu)造方法是GenericObjectPool(PoolableObjectFactory factory, GenericObjectPool.Config config) 。其中：

參數(shù)factory指明要與之配合使用的PoolableObjectFactory實(shí)例；
參數(shù)config則指明一個(gè)包括了各個(gè)參數(shù)的預(yù)設(shè)值的對(duì)象（詳見《GenericObjectPool.Config》一節(jié)）。
剩下的五個(gè)構(gòu)造函數(shù)則是最復(fù)雜的構(gòu)造方法在某方面的簡(jiǎn)化版本，可以根據(jù)情況選用。它們是：

GenericObjectPool(PoolableObjectFactory factory, int maxActive)
GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait)
GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn)
GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle)
GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)
這種對(duì)象池不可以在沒有Jakarta Commmons Collections組件支持的情況下運(yùn)行。

GenericObjectPool.Config
調(diào)用一個(gè)有很多的參數(shù)的方法的時(shí)候，很可能將參數(shù)的位置和個(gè)數(shù)搞錯(cuò)，導(dǎo)致編譯或運(yùn)行時(shí)的錯(cuò)誤；閱讀包含了有很多參數(shù)的方法調(diào)用的代碼的時(shí)候，也很可能因?yàn)闆]有搞對(duì)參數(shù)的位置和個(gè)數(shù)，產(chǎn)生錯(cuò)誤的理解。因此，人們往往避免給一個(gè)方法安排太多的參數(shù)的做法（所謂的“Long Parameter List”）。不過，有些方法又確實(shí)需要許多參數(shù)才能完成工作。于是，就有人想到了一種將大批的參數(shù)封裝到一個(gè)對(duì)象（稱為參數(shù)對(duì)象，Parameter Object）里，然后將這個(gè)對(duì)象作為單一的參數(shù)傳遞的兩全其美的對(duì)策。

因?yàn)樯蒅enericKeyedObjectPool時(shí)可供設(shè)置的特性非常之多，所以它的構(gòu)造方法里也就難免會(huì)需要不少的參數(shù)。GenericKeyedObjectPool除了提供了幾個(gè)超長(zhǎng)的構(gòu)造方法之外，同時(shí)也定義了一個(gè)使用參數(shù)對(duì)象的構(gòu)造方法。所用參數(shù)對(duì)象的類型是GenericKeyedObjectPool.Config。

GenericKeyedObjectPool.Config定義了許多的public字段，每個(gè)對(duì)應(yīng)一種可以為GenericKeyedObjectPool設(shè)置的特性，包括：

int maxActive
int maxIdle
long maxWait
long minEvictableIdleTimeMillis
int numTestsPerEvictionRun
boolean testOnBorrow
boolean testOnReturn
boolean testWhileIdle
long timeBetweenEvictionRunsMillis
byte whenExhaustedAction
這些字段的作用，與在GenericKeyedObjectPool最復(fù)雜的構(gòu)造方法中與它們同名的參數(shù)完全相同。

使用的時(shí)候，先生成一個(gè)GenericKeyedObjectPool.Config對(duì)象，然后將個(gè)字段設(shè)置為想要的值，最后用這個(gè)對(duì)象作為唯一的參數(shù)調(diào)用GenericKeyedObjectPool的構(gòu)造方法即可。

注重：使用有許多public字段、卻沒有任何方法的類，也是一個(gè)人們往往加以避免的行為（所謂的“Data Class”）。不過這次GenericKeyedObjectPool特立獨(dú)行了一回。

帶鍵值的對(duì)象池
有時(shí)候，單用對(duì)池內(nèi)所有對(duì)象一視同仁的對(duì)象池，并不能解決的問題。例如，對(duì)于一組某些參數(shù)設(shè)置不同的同類對(duì)象??比如一堆指向不同地址的java.net.URL對(duì)象或者一批代表不同語(yǔ)句的java.sql.PreparedStatement對(duì)象，用這樣的方法池化，就有可能取出不合用的對(duì)象的麻煩。

可以通過為每一組參數(shù)相同的同類對(duì)象建立一個(gè)單獨(dú)的對(duì)象池來解決這個(gè)問題。但是，假如使用普通的ObjectPool來實(shí)施這個(gè)計(jì)策的話，因?yàn)槠胀ǖ腜oolableObjectFactory只能生產(chǎn)出大批設(shè)置完全一致的對(duì)象，就需要為每一組參數(shù)相同的對(duì)象編寫一個(gè)單獨(dú)的PoolableObjectFactory，工作量相當(dāng)可觀。這種時(shí)候就適合調(diào)遣Pool組件中提供的一種“帶鍵值的對(duì)象池”來展開工作了。

Pool組件采用實(shí)現(xiàn)了KeyedObjectPool接口的類，來充當(dāng)帶鍵值的對(duì)象池。相應(yīng)的，這種對(duì)象池需要配合實(shí)現(xiàn)了KeyedPoolableObjectFactory接口的類和實(shí)現(xiàn)了KeyedObjectPoolFactory接口的類來使用（這三個(gè)接口都在org.apache.commons.pool包中定義）：

KeyedPoolableObjectFactory和PoolableObjectFactory形式如出一轍，只是每個(gè)方法都增加了一個(gè)Object key參數(shù)而已：

makeObject的參數(shù)變?yōu)?Object key)
activateObject的參數(shù)變?yōu)?Object key, Object obj)
passivateObject的參數(shù)變?yōu)?Object key, Object obj)
validateObject的參數(shù)變?yōu)镺bject key, Object obj)
destroyObject的參數(shù)變?yōu)?Object key, Object obj)
另外Pool組件也提供了BaseKeyedPoolableObjectFactory，用于充當(dāng)和BasePoolableObjectFactory差不多的角色。

KeyedObjectPool和ObjectPool的形式大同小異，只是某些方法的參數(shù)類型發(fā)生了變化，某些方法分成了兩種略有不同的版本：

用Object borrowObject(Object key)和void returnObject(Object key, Object obj)來負(fù)責(zé)對(duì)象出借和歸還的動(dòng)作。
用void close()來關(guān)閉不再需要的對(duì)象池。
用void clear(Object key)和void clear()來清空池中的對(duì)象，前者針對(duì)與特定鍵值相關(guān)聯(lián)的實(shí)例，后者針對(duì)整個(gè)對(duì)象池。
用int getNumActive(Object key)和int getNumActive()來查詢已借出的對(duì)象數(shù)，前者針對(duì)與特定鍵值相關(guān)聯(lián)的實(shí)例，后者針對(duì)整個(gè)對(duì)象池。
用int getNumIdle(Object key)和int getNumIdle()來查詢正在休眠的對(duì)象數(shù)，前者針對(duì)與特定鍵值相關(guān)聯(lián)的實(shí)例，后者針對(duì)整個(gè)對(duì)象池。
用void setFactory(KeyedPoolableObjectFactory factory)來設(shè)置要用的KeyedPoolableObjectFactory實(shí)例。
void clear、int getNumActive、int getNumIdle和void setFactory的各種版本都仍然是可以由具體實(shí)現(xiàn)自行決定是否要支持的方法。假如所用的KeyedObjectPool實(shí)現(xiàn)不支持這些操作，那么調(diào)用這些方法的時(shí)候，會(huì)拋出一個(gè)UnsupportedOperationException異常。

KeyedObjectPoolFactory和ObjectPoolFactory的形式完全相同，只是所代表的對(duì)象不同而已。
這一類對(duì)象池的基本使用方法接近于這樣：

KeyedObjectPoolSample.java

import org.apache.commons.pool.BaseKeyedPoolableObjectFactory;
import org.apache.commons.pool.KeyedObjectPool;
import org.apache.commons.pool.KeyedObjectPoolFactory;
import org.apache.commons.pool.KeyedPoolableObjectFactory;
import org.apache.commons.pool.impl.StackKeyedObjectPoolFactory;

class KeyedPoolableObjectFactorySample
extends BaseKeyedPoolableObjectFactory {

public Object makeObject(Object key) throws Exception {
return new String("[" + key.hashCode() + "]");
}

}

public class KeyedObjectPoolSample {
public static void main(String[] args) {
Object obj = null;
KeyedPoolableObjectFactory factory
= new KeyedPoolableObjectFactorySample();
KeyedObjectPoolFactory poolFactory
= new StackKeyedObjectPoolFactory(factory);
KeyedObjectPool pool = poolFactory.createPool();
String key = null;
try {
for (long i = 0; i < 100 ; i++) {
key = "" + (int) (Math.random() * 10);
System.out.println("== " + i + " ==");
System.out.println("Key:" + key);
obj = pool.borrowObject(key);
System.out.println("Object:" + obj);
pool.returnObject(key, obj);
obj = null;
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
try{
if (obj != null) {
pool.returnObject(key, obj);
}
pool.close();
}
catch (Exception e){
e.printStackTrace();
}
}
}
}

Pool組件自帶的KeyedObjectPool的實(shí)現(xiàn)有StackKeyedObjectPool和GenericKeyedObjectPool兩種。它們的使用方法分別與它們各自的近親KeyedObjectPool和KeyedObjectPool基本一致，只是原來使用GenericObjectPool.Config的地方要使用GenericKeyedObjectPool.Config代替。

當(dāng)出借少于歸還
Java并未提供一種機(jī)制來保證兩個(gè)方法被調(diào)用的次數(shù)之間呈現(xiàn)一種特定的關(guān)系（相等，相差一個(gè)常數(shù)，或是其它任何關(guān)系）。因此，完全可以做到建立一個(gè)ObjectPool對(duì)象，然后調(diào)用一次borrowObject方法，借出一個(gè)對(duì)象，之后重復(fù)兩次returnObject方法調(diào)用，進(jìn)行兩次歸還。而調(diào)用一個(gè)從不曾借出對(duì)象的ObjectPool的returnObject方法也并不是一個(gè)不可完成的任務(wù)。

盡管這些使用方法并不合乎returnObject的字面意思，但是Pool組件中的各個(gè)ObjectPool/KeyedObjectPool實(shí)現(xiàn)都不在乎這一點(diǎn)。它們的returnObject方法都只是單純地召喚與當(dāng)前對(duì)象池關(guān)聯(lián)的PoolableObjectFactory實(shí)例，看這對(duì)象能否經(jīng)受得起validateObject的考驗(yàn)而已。考驗(yàn)的結(jié)果決定了這個(gè)對(duì)象是應(yīng)該拿去作passivateObject處理，而后留待重用；還是應(yīng)該拿去作destroyObject處理，以免占用資源。也就是說，當(dāng)出借少于歸還的時(shí)候，并不會(huì)額外發(fā)生什么非凡的事情（當(dāng)然，有可能因?yàn)樵搶?duì)象池處于不接受歸還對(duì)象的請(qǐng)求的狀態(tài)而拋出異常，不過這是常規(guī)現(xiàn)象）。

在實(shí)際使用中，可以利用這一特性來向?qū)ο蟪貎?nèi)加入通過其它方法生成的對(duì)象。

線程安全問題
有時(shí)候可能要在多線程環(huán)境下使用Pool組件，這時(shí)候就會(huì)碰到和Pool組件的線程安全程度有關(guān)的問題。

因?yàn)镺bjectPool和KeyedObjectPool都是在org.apache.commons.pool中定義的接口，而在接口中無(wú)法使用“synchronized”來修飾方法，所以，一個(gè)ObjectPool/KeyedObjectPool下的各個(gè)方法是否是同步方法，完全要看具體的實(shí)現(xiàn)。而且，單純地使用了同步方法，也并不能使對(duì)象就此在多線程環(huán)境里高枕無(wú)憂。

就Pool組件中自帶的幾個(gè)ObjectPool/KeyedObjectPool的實(shí)現(xiàn)而言，它們都在一定程度上考慮了在多線程環(huán)境中使用的情況。不過還不能說它們是完全“線程安全”的。

例如，這段代碼有些時(shí)候就會(huì)有一些希奇的表現(xiàn)，最后輸出的結(jié)果比預(yù)期的要大：

UnsafeMultiThreadPoolingSample.java

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;

class UnsafePicker extends Thread {
private ObjectPool pool;
public UnsafePicker(ObjectPool op) {
pool = op;
}
public void run() {
Object obj = null;
try {
/* 似乎…… */
if ( pool.getNumActive() < 5 ) {
sleep((long) (Math.random() * 10));
obj = pool.borrowObject();
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}

public class UnsafeMultiThreadPoolingSample {

public static void main(String[] args) {
ObjectPool pool = new StackObjectPool
(new BasePoolableObjectFactorySample());
Thread ts[] = new Thread[20];
for (int j = 0; j < ts.length; j++) {
ts[j] = new UnsafePicker(pool);
ts[j].start();
}
try {
Thread.sleep(1000);
/* 然而…… */
System.out.println("NumActive:" + pool.getNumActive());
}
catch (Exception e) {
e.printStackTrace();
}
}
}

要避免這種情況，就要進(jìn)一步采取一些措施才行：

SafeMultiThreadPoolingSample.java

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;

class SafePicker extends Thread {
private ObjectPool pool;
public SafePicker(ObjectPool op) {
pool = op;
}
public void run() {
Object obj = null;
try {
/* 略加處理 */
synchronized (pool) {
if ( pool.getNumActive() < 5 ) {
sleep((long) (Math.random() * 10));
obj = pool.borrowObject();
}
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}

public class SafeMultiThreadPoolingSample {

public static void main(String[] args) {
ObjectPool pool = new StackObjectPool
(new BasePoolableObjectFactorySample());
Thread ts[] = new Thread[20];
for (int j = 0; j < ts.length; j++) {
ts[j] = new SafePicker(pool);
ts[j].start();
}
try {
Thread.sleep(1000);
System.out.println("NumActive:" + pool.getNumActive());
}
catch (Exception e) {
e.printStackTrace();
}
}
}

基本上，可以說Pool組件是線程相容的。但是要在多線程環(huán)境中使用，還需要作一些非凡的處理。

什么時(shí)候不要池化
采用對(duì)象池化的本意，是要通過減少對(duì)象生成的次數(shù)，減少花在對(duì)象初始化上面的開銷，從而提高整體的性能。然而池化處理本身也要付出代價(jià)，因此，并非任何情況下都適合采用對(duì)象池化。

Dr. Cliff Click在JavaOne 2003上發(fā)表的《Performance Myths EXPosed》中，給出了一組其它條件都相同時(shí)，使用與不使用對(duì)象池化技術(shù)的實(shí)際性能的比較結(jié)果。他的實(shí)測(cè)結(jié)果表明：

對(duì)于類似Point這樣的輕量級(jí)對(duì)象，進(jìn)行池化處理后，性能反而下降，因此不宜池化；

對(duì)于類似Hashtable這樣的中量級(jí)對(duì)象，進(jìn)行池化處理后，性能基本不變，一般不必池化（池化會(huì)使代碼變復(fù)雜，增大維護(hù)的難度）；
對(duì)于類似JPanel這樣的重量級(jí)對(duì)象，進(jìn)行池化處理后，性能有所上升，可以考慮池化。
根據(jù)使用方法的不同，實(shí)際的情況可能與這一測(cè)量結(jié)果略有出入。在配置較高的機(jī)器和技術(shù)較強(qiáng)的虛擬機(jī)上，不宜池化的對(duì)象的范圍可能會(huì)更大。不過，對(duì)于像網(wǎng)絡(luò)和數(shù)據(jù)庫(kù)連接這類重量級(jí)的對(duì)象來說，目前還是有池化的必要。

基本上，只在重復(fù)生成某種對(duì)象的操作成為影響性能的要害因素的時(shí)候，才適合進(jìn)行對(duì)象池化。假如進(jìn)行池化所能帶來的性能提高并不重要的話，還是不采用對(duì)象池化技術(shù)，以保持代碼的簡(jiǎn)明，而使用更好的硬件和更棒的虛擬機(jī)來提高性能為佳。

結(jié)束語(yǔ)
恰當(dāng)?shù)厥褂脤?duì)象池化，可以有效地降低頻繁生成某些對(duì)象所造成的開銷，從而提高整體的性能。而借助Jakarta Commons Pool組件，可以有效地減少花在處理對(duì)象池化上的工作量，進(jìn)而，向其它重要的工作里，投入更多的時(shí)間和精力。

參考資料

很多疑難問題的答案都可以通過查閱Pool組件的Javadoc文檔和源代碼的方法解決。

從 Pool組件的官方站點(diǎn) 上，還可以進(jìn)一步得到許多有用的信息。

DBCP 是一個(gè)基于Pool組件的Java數(shù)據(jù)庫(kù)連接池治理組件，同時(shí)也可以作為Pool組件的用法示例使用。

蔡學(xué)鏞在《Java夜未眠（Sleepless Java）》中的《測(cè)不準(zhǔn)原理》一文里，介紹了Java中的包括“軟引用”（Soft Reference）在內(nèi)的各種不同的引用的特點(diǎn)和用處。

Martin Fowler在《Refactoring -- Improving the Design of Existing Code》（中譯本名為《重構(gòu)??改善既有代碼的設(shè)計(jì)》，由侯捷、熊節(jié)合譯）一書的第三章《代碼的壞味道（Bad Smells in Code）》中討論了被稱為“Long Parameter List”和“Data Class”的“壞味道”。并指明了一些可以用于對(duì)付這些問題的重構(gòu)手法。

Brian Goetz在IBM developerWorks上發(fā)表的《Java 理論與實(shí)踐：描繪線程安全性》一文中，說明了為什么單純地使用同步方法還不能讓對(duì)象就此在多線程環(huán)境里高枕無(wú)憂的原因。

Dr. Cliff Click發(fā)表在JavaOne 2003上的《Performance Myths Exposed》（session #1522），給出了一組包括“對(duì)象池化”在內(nèi)的、對(duì)“能提高Java程序性能”的做法的實(shí)際效果的測(cè)試數(shù)據(jù)，和一些恰當(dāng)使用這些做法的建議。

關(guān)于作者
孫海濤從1994年6月的一個(gè)風(fēng)雨交加的下午開始了他的編程生涯。目前，他的愛好集中于Java、Web、開源軟件和人機(jī)交互。但是，這并不表示他不會(huì)對(duì)其它的事物給予足夠的關(guān)心和重視。可以通過 alexhsun@hotmail.com 與他取得聯(lián)系。

上一篇：使用Java Swing 創(chuàng)建一個(gè)XML編輯器（一）

下一篇：使用Java Data Object(JDO)存放持久性數(shù)據(jù)