对象池化

 

Apache对象池技术的实现上颇为简单，只有2个主要的对象：ObjectPool，用于管理对象池中所有的对象，以及对象的借出，和回收。PoolableObjectFactory，被ObjectPool生成，借出和回收的对象。之所以叫做Factory，只是是因为它导出了几个负责生命期管理的函数：makeObject，destoryObject，activeObject...。

        ObjectPool维护一个列表，其中存放所有已经生成的对象。同时导出几个方法，如borrowObject，returnObject，addObject等等。当用户调用borrowObject时，ObjectPool查看当前列表中的空闲对象的数目，如果有空闲的对象，则初始化该对象后返回给用户，否则创建一个对象，返回给用户使用。同理，当用户调用returnObject时，ObjectPool查看当前队列中的空闲对象数目，如果数目小于DEFAULT_MAX_SLEEPING，则将改对象的状态清空，然后放到队列中，作为备用对象；否则直接销毁改对象。

        这种备用的观念正是对象池的理论基础，可以很大程度上减少对象生成和销毁的次数。对于那些初始化过程很慢的对象来说，减少对象构造和销毁的次数就等于大幅度提高了整体效率。特别是对于数据库连接这样的对象，由于进行JNDI搜索的效率极为低下，应用对象池技术是理所当然的。

        Apache的commons - pool使用起来非常简单，首先需要创建一个你认为有必要池化的对象，实现PoolableObejctFactory的几个方法。然后构造一种ObjectPool。Apache默认提供了3种ObjectPool：StackObjectPool，GenericObjectPool，SoftReferenceObejctPool，一般使用StackObejctPool就可以了。然后当需要创建对象时，使用StackObejctPool.borrowObejct；使用完对象后，调用StackObjectPool.returnObject，就完成了对象池的操作。

        需要注意的是，对象池技术并不是对任何对象都适用。因为对象池本身的操作要耗费一些资源，对于一些小对象来说，使用对象池可能取得相反的效果。IBM DeveloperWorks上有一篇论文，指出简单对象如Point,Size等，使用对象池技术并不能带来性能的该改善；而复杂对象如JPanel,JFrame等，使用对象池后能带来稍微的性能优势；最最适合对象池技术的是一些耗时操作，如JDBC连接，线程等。    
 

利用ObjectPoolFactory

有时候，要在多处生成类型和设置都相同的ObjectPool。如果在每个地方都重写一次调用相应构造方法的代码，不但比较麻烦，而且日后修改起来，也有所不便。这种时候，正是使用ObjectPoolFactory的时机。 

ObjectPoolFactory是一个在org.apache.commons.pool中定义的接口，它定义了一个称为ObjectPool createPool()方法，可以用于大量生产类型和设置都相同的ObjectPool。 

Pool组件中，对每一个ObjectPool实现，都有一个对应的ObjectPoolFactory实现。它们相互之间，有一一对应的参数相同的构造方法。使用的时候，只要先用想要的参数和想用的ObjectPoolFactory实例，构造出一个ObjectPoolFactory对象，然后在需要生成ObjectPool的地方，调用这个对象的createPool()方法就可以了。日后无论想要调整所用ObjectPool的参数还是类型，只需要修改这一处，就可以大功告成了。 

将 《使用ObjectPool》一节中的例子，改为使用ObjectPoolFactory来生成所用的ObjectPool对象之后，基本就是这种形式： 

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定义了许多方法，可以适应多种不同的情况。但是，在并没有什么特殊需要的时候，直接实现PoolableObjectFactory接口，就要编写若干的不进行任何操作，或是始终返回true的方法来让编译通过，比较繁琐。这种时候就可以借助BasePoolableObjectFactory的威力，来简化编码的工作。 

BasePoolableObjectFactory是org.apache.commons.pool包中的一个抽象类。它实现了PoolableObjectFactory接口，并且为除了makeObject之外的方法提供了一个基本的实现――activateObject、passivateObject和destroyObject不进行任何操作，而validateObject始终返回true。通过继承这个类，而不是直接实现PoolableObjectFactory接口，就可以免去编写一些只起到让编译通过的作用的代码的麻烦了。 

这个例子展示了一个从BasePoolableObjectFactory扩展而来的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

可口可乐公司的软饮料有可口可乐、雪碧和芬达等品种，百事可乐公司的软饮料有百事可乐、七喜和美年达等类型，而Pool组件提供的ObjectPool实现则有StackObjectPool、SoftReferenceObjectPool和GenericObjectPool等种类。 

不同类型的软饮料各有各自的特点，分别适应不同消费者的口味；而不同类型的ObjectPool也各有各自的特色，分别适应不同的情况。 



 


 回页首 
 



StackObjectPool

StackObjectPool利用一个java.util.Stack对象来保存对象池里的对象。这种对象池的特色是： 

可以为对象池指定一个初始的参考大小（当空间不够时会自动增长）。 
在对象池已空的时候，调用它的borrowObject方法，会自动返回新创建的实例。 
可以为对象池指定一个可保存的对象数目的上限。达到这个上限之后，再向池里送回的对象会被自动送去回收。 
StackObjectPool的构造方法共有六个，其中： 

最简单的一个是StackObjectPool()，一切采用默认的设置，也不指明要用的PoolableObjectFactory实例。 
最复杂的一个则是StackObjectPool(PoolableObjectFactory factory,  int  max,  int  init)。其中： 
参数factory指明要与之配合使用的PoolableObjectFactory实例； 
参数max设定可保存对象数目的上限； 
参数init则指明初始的参考大小。 
剩余的四个构造方法则是最复杂的构造方法在某方面的简化版本，可以根据需要选用。它们是： 
StackObjectPool( int  max) 
StackObjectPool( int  max,  int  init) 
StackObjectPool(PoolableObjectFactory factory) 
StackObjectPool(PoolableObjectFactory factory,  int  max) 
用不带factory参数的构造方法构造的StackObjectPool实例，必须要在用它的setFactory(PoolableObjectFactory factory)方法与某一PoolableObjectFactory实例关联起来后才能正常使用。 

这种对象池可以在没有Jakarta Commmons Collections组件支持的情况下正常运行。 



 


 回页首 
 



SoftReferenceObjectPool

SoftReferenceObjectPool利用一个java.util.ArrayList对象来保存对象池里的对象。不过它并不在对象池里直接保存对象本身，而是保存它们的“软引用”（Soft Reference）。这种对象池的特色是： 

可以保存任意多个对象，不会有容量已满的情况发生。 
在对象池已空的时候，调用它的borrowObject方法，会自动返回新创建的实例。 
可以在初始化同时，在池内预先创建一定量的对象。 
当内存不足的时候，池中的对象可以被Java虚拟机回收。 
SoftReferenceObjectPool的构造方法共有三个，其中： 

最简单的是SoftReferenceObjectPool()，不预先在池内创建对象，也不指明要用的PoolableObjectFactory实例。 
最复杂的一个则是SoftReferenceObjectPool(PoolableObjectFactory factory,  int  initSize)。其中： 
参数factory指明要与之配合使用的PoolableObjectFactory实例 
参数initSize则指明初始化时在池中创建多少个对象。 
剩下的一个构造方法，则是最复杂的构造方法在某方面的简化版本，适合在大多数情况下使用。它是： 
SoftReferenceObjectPool(PoolableObjectFactory factory) 
用不带factory参数的构造方法构造的SoftReferenceObjectPool实例，也要在用它的setFactory(PoolableObjectFactory factory)方法与某一PoolableObjectFactory实例关联起来后才能正常使用。 

这种对象池也可以在没有Jakarta Commmons Collections组件支持的情况下正常运行。 



 


 回页首 
 



GenericObjectPool

GenericObjectPool利用一个org.apache.commons.collections.CursorableLinkedList对象来保存对象池里的对象。这种对象池的特色是： 

可以设定最多能从池中借出多少个对象。 
可以设定池中最多能保存多少个对象。 
可以设定在池中已无对象可借的情况下，调用它的borrowObject方法时的行为，是等待、创建新的实例还是抛出异常。 
可以分别设定对象借出和还回时，是否进行有效性检查。 
可以设定是否使用一个单独的线程，对池内对象进行后台清理。 
GenericObjectPool的构造方法共有七个，其中： 

最简单的一个是GenericObjectPool(PoolableObjectFactory factory)。仅仅指明要用的PoolableObjectFactory实例，其它参数则采用默认值。 
最复杂的一个是GenericObjectPool(PoolableObjectFactory factory,  int  maxActive,  byte  whenExhaustedAction,  long  maxWait,  int  maxIdle, boolean testOnBorrow, boolean testOnReturn,  long  timeBetweenEvictionRunsMillis,  int  numTestsPerEvictionRun,  long  minEvictableIdleTimeMillis, boolean testWhileIdle)。其中： 
参数factory指明要与之配合使用的PoolableObjectFactory实例。 
参数maxActive指明能从池中借出的对象的最大数目。如果这个值不是正数，表示没有限制。 
参数whenExhaustedAction指定在池中借出对象的数目已达极限的情况下，调用它的borrowObject方法时的行为。可以选用的值有： 
GenericObjectPool.WHEN_EXHAUSTED_BLOCK，表示等待； 
GenericObjectPool.WHEN_EXHAUSTED_GROW，表示创建新的实例（不过这就使maxActive参数失去了意义）； 
GenericObjectPool.WHEN_EXHAUSTED_FAIL，表示抛出一个java.util.NoSuchElementException异常。 
参数maxWait指明若在对象池空时调用borrowObject方法的行为被设定成等待，最多等待多少毫秒。如果等待时间超过了这个数值，则会抛出一个java.util.NoSuchElementException异常。如果这个值不是正数，表示无限期等待。 
参数testOnBorrow设定在借出对象时是否进行有效性检查。 
参数testOnBorrow设定在还回对象时是否进行有效性检查。 
参数timeBetweenEvictionRunsMillis，设定间隔每过多少毫秒进行一次后台对象清理的行动。如果这个值不是正数，则实际上不会进行后台对象清理。 
参数numTestsPerEvictionRun，设定在进行后台对象清理时，每次检查几个对象。如果这个值不是正数，则每次检查的对象数是检查时池内对象的总数乘以这个值的负倒数再向上取整的结果――也就是说，如果这个值是 - 2 （ - 3 、 - 4 、 - 5 ……）的话，那么每次大约检查当时池内对象总数的1 / 2 （ 1 / 3 、 1 / 4 、 1 / 5 ……）左右。 
参数minEvictableIdleTimeMillis，设定在进行后台对象清理时，视休眠时间超过了多少毫秒的对象为过期。过期的对象将被回收。如果这个值不是正数，那么对休眠时间没有特别的约束。 
参数testWhileIdle，则设定在进行后台对象清理时，是否还对没有过期的池内对象进行有效性检查。不能通过有效性检查的对象也将被回收。 
另一个比较特别的构造方法是GenericObjectPool(PoolableObjectFactory factory, GenericObjectPool.Config config) 。其中： 
参数factory指明要与之配合使用的PoolableObjectFactory实例； 
参数config则指明一个包括了各个参数的预设值的对象（详见《GenericObjectPool.Config》一节）。 
剩下的五个构造函数则是最复杂的构造方法在某方面的简化版本，可以根据情况选用。它们是： 
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) 
这种对象池不可以在没有Jakarta Commmons Collections组件支持的情况下运行。 



 


 回页首 
 



GenericObjectPool.Config

调用一个有很多的参数的方法的时候，很可能将参数的位置和个数搞错，导致编译或运行时的错误；阅读包含了有很多参数的方法调用的代码的时候，也很可能因为没有搞对参数的位置和个数，产生错误的理解。因此，人们往往避免给一个方法安排太多的参数的做法（所谓的“Long Parameter List”）。不过，有些方法又确实需要许多参数才能完成工作。于是，就有人想到了一种将大批的参数封装到一个对象（称为参数对象，Parameter Object）里，然后将这个对象作为单一的参数传递的两全其美的对策。 

因为生成GenericKeyedObjectPool时可供设置的特性非常之多，所以它的构造方法里也就难免会需要不少的参数。GenericKeyedObjectPool除了提供了几个超长的构造方法之外，同时也定义了一个使用参数对象的构造方法。所用参数对象的类型是GenericKeyedObjectPool.Config。 

GenericKeyedObjectPool.Config定义了许多的public字段，每个对应一种可以为GenericKeyedObjectPool设置的特性，包括： 

int  maxActive 
int  maxIdle 
long  maxWait 
long  minEvictableIdleTimeMillis 
int  numTestsPerEvictionRun 
boolean testOnBorrow 
boolean testOnReturn 
boolean testWhileIdle 
long  timeBetweenEvictionRunsMillis 
byte  whenExhaustedAction 
这些字段的作用，与在GenericKeyedObjectPool最复杂的构造方法中与它们同名的参数完全相同。 

使用的时候，先生成一个GenericKeyedObjectPool.Config对象，然后将个字段设置为想要的值，最后用这个对象作为唯一的参数调用GenericKeyedObjectPool的构造方法即可。 

注意：使用有许多public字段、却没有任何方法的类，也是一个人们往往加以避免的行为（所谓的“Data Class”）。不过这次GenericKeyedObjectPool特立独行了一回。 



 


 回页首 
 



带键值的对象池

有时候，单用对池内所有对象一视同仁的对象池，并不能解决的问题。例如，对于一组某些参数设置不同的同类对象――比如一堆指向不同地址的java.net.URL对象或者一批代表不同语句的java.sql.PreparedStatement对象，用这样的方法池化，就有可能取出不合用的对象的麻烦。 

可以通过为每一组参数相同的同类对象建立一个单独的对象池来解决这个问题。但是，如果使用普通的ObjectPool来实施这个计策的话，因为普通的PoolableObjectFactory只能生产出大批设置完全一致的对象，就需要为每一组参数相同的对象编写一个单独的PoolableObjectFactory，工作量相当可观。这种时候就适合调遣Pool组件中提供的一种“带键值的对象池”来展开工作了。 

Pool组件采用实现了KeyedObjectPool接口的类，来充当带键值的对象池。相应的，这种对象池需要配合实现了KeyedPoolableObjectFactory接口的类和实现了KeyedObjectPoolFactory接口的类来使用（这三个接口都在org.apache.commons.pool包中定义）： 

KeyedPoolableObjectFactory和PoolableObjectFactory形式如出一辙，只是每个方法都增加了一个Object key参数而已： 
makeObject的参数变为(Object key) 
activateObject的参数变为(Object key, Object obj) 
passivateObject的参数变为(Object key, Object obj) 
validateObject的参数变为Object key, Object obj) 
destroyObject的参数变为(Object key, Object obj) 
另外Pool组件也提供了BaseKeyedPoolableObjectFactory，用于充当和BasePoolableObjectFactory差不多的角色。

KeyedObjectPool和ObjectPool的形式大同小异，只是某些方法的参数类型发生了变化，某些方法分成了两种略有不同的版本： 
用Object borrowObject(Object key)和void returnObject(Object key, Object obj)来负责对象出借和归还的动作。 
用void close()来关闭不再需要的对象池。 
用void clear(Object key)和void clear()来清空池中的对象，前者针对与特定键值相关联的实例，后者针对整个对象池。 
用int getNumActive(Object key)和int getNumActive()来查询已借出的对象数，前者针对与特定键值相关联的实例，后者针对整个对象池。 
用int getNumIdle(Object key)和int getNumIdle()来查询正在休眠的对象数，前者针对与特定键值相关联的实例，后者针对整个对象池。 
用void setFactory(KeyedPoolableObjectFactory factory)来设置要用的KeyedPoolableObjectFactory实例。 
void  clear、 int  getNumActive、 int  getNumIdle和void setFactory的各种版本都仍然是可以由具体实现自行决定是否要支持的方法。如果所用的KeyedObjectPool实现不支持这些操作，那么调用这些方法的时候，会抛出一个UnsupportedOperationException异常。 

KeyedObjectPoolFactory和ObjectPoolFactory的形式完全相同，只是所代表的对象不同而已。 
这一类对象池的基本使用方法接近于这样： 

                                
          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的实现有StackKeyedObjectPool和GenericKeyedObjectPool两种。它们的使用方法分别与它们各自的近亲KeyedObjectPool和KeyedObjectPool基本一致，只是原来使用GenericObjectPool.Config的地方要使用GenericKeyedObjectPool.Config代替。 



 


 回页首 
 



当出借少于归还

Java并未提供一种机制来保证两个方法被调用的次数之间呈现一种特定的关系（相等，相差一个常数，或是其它任何关系）。因此，完全可以做到建立一个ObjectPool对象，然后调用一次borrowObject方法，借出一个对象，之后重复两次returnObject方法调用，进行两次归还。而调用一个从不曾借出对象的ObjectPool的returnObject方法也并不是一个不可完成的任务。 

尽管这些使用方法并不合乎returnObject的字面意思，但是Pool组件中的各个ObjectPool / KeyedObjectPool实现都不在乎这一点。它们的returnObject方法都只是单纯地召唤与当前对象池关联的PoolableObjectFactory实例，看这对象能否经受得起validateObject的考验而已。考验的结果决定了这个对象是应该拿去作passivateObject处理，而后留待重用；还是应该拿去作destroyObject处理，以免占用资源。也就是说，当出借少于归还的时候，并不会额外发生什么特别的事情（当然，有可能因为该对象池处于不接受归还对象的请求的状态而抛出异常，不过这是常规现象）。 

在实际使用中，可以利用这一特性来向对象池内加入通过其它方法生成的对象。 



 


 回页首 
 



线程安全问题

有时候可能要在多线程环境下使用Pool组件，这时候就会遇到和Pool组件的线程安全程度有关的问题。 

因为ObjectPool和KeyedObjectPool都是在org.apache.commons.pool中定义的接口，而在接口中无法使用“synchronized”来修饰方法，所以，一个ObjectPool / KeyedObjectPool下的各个方法是否是同步方法，完全要看具体的实现。而且，单纯地使用了同步方法，也并不能使对象就此在多线程环境里高枕无忧。 

就Pool组件中自带的几个ObjectPool / KeyedObjectPool的实现而言，它们都在一定程度上考虑了在多线程环境中使用的情况。不过还不能说它们是完全“线程安全”的。 

例如，这段代码有些时候就会有一些奇怪的表现，最后输出的结果比预期的要大： 

                                
          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();
        }
    }
}
 



要避免这种情况，就要进一步采取一些措施才行： 

                                
          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组件是线程相容的。但是要在多线程环境中使用，还需要作一些特别的处理。