Commons-pool是一个apache开源组织下的众多项目的一个。其被广泛地整合到众多需要对象池功能的项目中。
官网:http://commons.apache.org/proper/commons-pool/
本文是commons-pool的一个简单应用,包括不带key的池和带key的池。带key的池是把key相同的池对象放在一起池里,也就是说有多少个key就有多少个池。
不带key的池是生产完全一致的对象放在池里,但是有时候,单用对池内所有对象一视同仁的对象池,并不能解决的问题。例如,对于一组某些参数设置不同的同类对象――比如一堆指向不同地址的 java.net.URL对象或者一批代表不同语句的java.sql.PreparedStatement对象,用这样的方法池化,就有可能取出不合用 的对象的麻烦。这里对带key的池也做了简单的例子。
Commons-pool将对象池化的工作安排给了三类对象:
1. PoolableObjectFactory(KeyedPoolableObjectFactory):用于管理被池化对象的产生,激活,挂起,检验和销毁。
2. ObjectPool(KeyedObjectPool):用于管理要被池化的对象的接触和归还,并通过PoolableObjectFactory完成相应的操作。
3. ObjectPoolFactory(KeyedObjectPoolFactory):ObjectPool的工厂,里边有createPool()方法,用于大量生成相同类型和设置的池。
1.下载相关jar包以及文档
2.编写测试例子,新建项目只需要导入commons-pool-1.6.jar一个就可以
1)实体对象BaseObject.java
- public class BaseObject {
- //记录从池中取出次数
- private int num;
- private boolean active;
- public BaseObject(){
- active = true;
- System.out.println("new BaseObject!!!!!");
- }
- //省略get set
2)管理池里对象的产生,激活,挂起,检验和销毁的工厂类
- public class TestPoolableFactory implements PoolableObjectFactory {
- //重新初始化实例返回池
- @Override
- public void activateObject(Object arg0) throws Exception {
- ((BaseObject)arg0).setActive(true);
- }
- //销毁被破坏的实例
- @Override
- public void destroyObject(Object arg0) throws Exception {
- arg0 = null;
- }
- //创建一个实例到对象池
- @Override
- public Object makeObject() throws Exception {
- BaseObject bo = new BaseObject();
- return bo;
- }
- //取消初始化实例返回到空闲对象池
- @Override
- public void passivateObject(Object arg0) throws Exception {
- ((BaseObject)arg0).setActive(false);
- }
- //验证该实例是否安全
- @Override
- public boolean validateObject(Object arg0) {
- if(((BaseObject)arg0).isActive())
- return true;
- else
- return false;
- }
- }
- public class TestKeyPoolableFactory implements KeyedPoolableObjectFactory<String, BaseObject> {
- //重新初始化实例返回池
- @Override
- public void activateObject(String arg0, BaseObject arg1) throws Exception {
- ((BaseObject)arg1).setActive(true);
- }
- //销毁被破坏的实例
- @Override
- public void destroyObject(String arg0, BaseObject arg1) throws Exception {
- arg1 = null;
- }
- //创建一个实例到对象池
- @Override
- public BaseObject makeObject(String arg0) throws Exception {
- //这里从数据库里查询出使用次数最少的配置
- BaseObject bo = new BaseObject();
- bo.setNum(0);
- return bo;
- }
- //取消初始化实例返回到空闲对象池
- @Override
- public void passivateObject(String arg0, BaseObject arg1) throws Exception {
- ((BaseObject)arg1).setActive(false);
- }
- //验证该实例是否安全 true:正在使用
- @Override
- public boolean validateObject(String arg0, BaseObject arg1) {
- //这里可以判断实例状态是否可用
- if(((BaseObject)arg1).isActive())
- return true;
- else
- return false;
- }
- }
3)测试main方法
不带key的main方法类PoolTest.java- public class PoolTest {
- public static void main(String[] args) {
- BaseObject bo = null;
- PoolableObjectFactory factory = new TestPoolableFactory();
- GenericObjectPool pool = new GenericObjectPool(factory);
- //这里两种池都可以,区别下文会提到
- //ObjectPool pool = new StackObjectPool(factory);
- try {
- for(int i = 0; i < 5; i++) {
- System.out.println("\n==========="+i+"===========");
- System.out.println("池中处于闲置状态的实例pool.getNumIdle():"+pool.getNumIdle());
- //从池里取一个对象,新创建makeObject或将以前闲置的对象取出来
- bo = (BaseObject)pool.borrowObject();
- System.out.println("bo:"+bo);
- System.out.println("池中所有在用实例数量pool.getNumActive():"+pool.getNumActive());
- if((i%2) == 0) {
- //用完之后归还对象
- pool.returnObject(bo);
- System.out.println("归还对象!!!!");
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- } finally {
- try {
- if(bo != null) {
- pool.returnObject(bo);
- }
- //关闭池
- pool.close();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }
- }
输出结果:
- ===========0===========
- 池中处于闲置状态的实例pool.getNumIdle():0
- new BaseObject!!!!!
- bo:common.keypool.BaseObject@1fdc96c
- 池中所有在用实例数量pool.getNumActive():1
- 归还对象!!!!
- ===========1===========
- 池中处于闲置状态的实例pool.getNumIdle():1
- bo:common.keypool.BaseObject@1fdc96c
- 池中所有在用实例数量pool.getNumActive():1
- ===========2===========
- 池中处于闲置状态的实例pool.getNumIdle():0
- new BaseObject!!!!!
- bo:common.keypool.BaseObject@124bbbf
- 池中所有在用实例数量pool.getNumActive():2
- 归还对象!!!!
- ===========3===========
- 池中处于闲置状态的实例pool.getNumIdle():1
- bo:common.keypool.BaseObject@124bbbf
- 池中所有在用实例数量pool.getNumActive():2
- ===========4===========
- 池中处于闲置状态的实例pool.getNumIdle():0
- new BaseObject!!!!!
- bo:common.keypool.BaseObject@a20892
- 池中所有在用实例数量pool.getNumActive():3
- 归还对象!!!!
这里的池声明用ObjectPool或者GenericObjectPool的区别在于:
ObjectPool这种对象池的特点是:
- 可以为对象池指定一个初始的参考大小(当空间不够时会自动增长)。
- 在对象池已空的时候,调用它的borrowObject方法,会自动返回新创建的实例。
- 可以为对象池指定一个可保存的对象数目的上限。达到这个上限之后,再向池里送回的对象会被自动送去回收。
GenericObjectPool这种对象池的特色是:
- 可以设定最多能从池中借出多少个对象。
- 可以设定池中最多能保存多少个对象。
- 可以设定在池中已无对象可借的情况下,调用它的borrowObject方法时的行为,是等待、创建新的实例还是抛出异常。
- 可以分别设定对象借出和还回时,是否进行有效性检查。
- 可以设定是否使用一个单独的线程,对池内对象进行后台清理。
- ……
源码GenericKeyedObjectPool.java类内部的setConfig方法
- /**
- * Sets the configuration.
- * @param conf the new configuration to use.
- * @see GenericKeyedObjectPool.Config
- */
- public synchronized void setConfig(GenericKeyedObjectPool.Config conf) {
- setMaxIdle(conf.maxIdle);
- setMaxActive(conf.maxActive);
- setMaxTotal(conf.maxTotal);
- setMinIdle(conf.minIdle);
- setMaxWait(conf.maxWait);
- setWhenExhaustedAction(conf.whenExhaustedAction);
- setTestOnBorrow(conf.testOnBorrow);
- setTestOnReturn(conf.testOnReturn);
- setTestWhileIdle(conf.testWhileIdle);
- setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
- setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
- setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
- }
源码GenericObjectPool.java类内部的setConfig方法
- /**
- * Sets my configuration.
- *
- * @param conf configuration to use.
- * @see GenericObjectPool.Config
- */
- public void setConfig(GenericObjectPool.Config conf) {
- synchronized (this) {
- setMaxIdle(conf.maxIdle);
- setMinIdle(conf.minIdle);
- setMaxActive(conf.maxActive);
- setMaxWait(conf.maxWait);
- setWhenExhaustedAction(conf.whenExhaustedAction);
- setTestOnBorrow(conf.testOnBorrow);
- setTestOnReturn(conf.testOnReturn);
- setTestWhileIdle(conf.testWhileIdle);
- setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);
- setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);
- setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);
- setSoftMinEvictableIdleTimeMillis(conf.softMinEvictableIdleTimeMillis);
- setLifo(conf.lifo);
- }
- allocate();
- }
1. 参数maxActive指明能从池中借出的对象的最大数目。如果这个值不是正数,表示没有限制。
2. 参数whenExhaustedA ction指定在池中借出对象的数目已达极限的情况下,调用它的borrowObject方法时的行为。可以选用的值有:
- GenericObjectPool.WHEN_EXHAUSTED_BLOCK,表示等待;
- GenericObjectPool.WHEN_EXHAUSTED_GROW,表示创建新的实例(不过这就使maxActive参数失去了意义);
- GenericObjectPool.WHEN_EXHAUSTED_FAIL,表示抛出一个java.util.NoSuchElementException异常。
3. 参数maxWait指明若在对象池空时调用borrowObject方法的行为被设定成等待,最多等待多少毫秒。如果等待时间超过了这个数值,则会抛出一个java.util.NoSuchElementException异常。如果这个值不是正数,表示无限期等待。
4. 参数testOnBorrow设定在借出对象时是否进行有效性检查。
5. 参数testOnBorrow设定在还回对象时是否进行有效性检查。
6. 参数timeBetweenEvictionRunsMillis,设定间隔每过多少毫秒进行一次后台对象清理的行动。如果这个值不是正数,则实际上不会进行后台对象清理。
7. 参数minEvictableIdleTimeMillis,设定在进行后台对象清理时,视休眠时间超过了多少毫秒的对象为过期。过期的对象将被回收。如果这个值不是正数,那么对休眠时间没有特别的约束。
8. 参数testWhileIdle,则设定在进行后台对象清理时,是否还对没有过期的池内对象进行有效性检查。不能通过有效性检查的对象也将被回收。
9. 参数lifo,池对象的放入和取出默认是后进先出的原则,默认是true,代表后进后出,设置为false代表先进先出。
带key的main方法类KeyPoolTest.java
- public class KeyPoolTest {
- public static void main(String[] args) {
- BaseObject bo = null;
- BaseObject bo1 = null;
- BaseObject bo2 = null;
- KeyedPoolableObjectFactory<String, BaseObject> keyFactory = new TestKeyPoolableFactory();
- GenericKeyedObjectPool<String, BaseObject> keyPool = new GenericKeyedObjectPool<String, BaseObject>(keyFactory);
- //keyPool.setLifo(false);
- try {
- //这里添加池对象,只需要传入key就会默认调用makeObject()方法创建一个对象
- keyPool.addObject("一级");
- keyPool.addObject("二级");
- //这里注释掉,不初始创建这个键的池对象
- //keyPool.addObject("三级");
- System.out.println("池中处于闲置状态的实例pool.getNumIdle():"+keyPool.getNumIdle());
- for (int i = 0; i < 5; i++) {
- //从池里取对象
- bo = keyPool.borrowObject("一级");
- bo.setNum(bo.getNum()+1);
- System.out.println("一级"+i+"-------"+bo+"-------"+bo.getNum());
- bo1 = keyPool.borrowObject("二级");
- bo1.setNum(bo1.getNum()+1);
- System.out.println("二级"+i+"-------"+bo1+"-------"+bo1.getNum());
- //上边注释掉的那行代码,这里取对象的时候如果没有闲置对象,也会默认去创建一个key="三级"的池对象
- bo2 = keyPool.borrowObject("三级");
- bo2.setNum(bo2.getNum()+1);
- System.out.println("三级"+i+"-------"+bo2+"-------"+bo2.getNum());
- if(i<3) {
- //用完之后归还对象
- keyPool.returnObject("一级", bo);
- keyPool.returnObject("二级", bo1);
- keyPool.returnObject("三级", bo2);
- System.out.println("归还对象!!!");
- }
- }
- //当前池里的实例数量
- System.out.println("池中所有在用实例pool.getNumActive():"+keyPool.getNumActive());
- //当前池里的处于闲置状态的实例
- System.out.println("池中处于闲置状态的实例pool.getNumIdle():"+keyPool.getNumIdle());
- } catch (Exception e) {
- e.printStackTrace();
- }
- //这里就不写finally了,偷懒了,这里应该关闭池的
- }
- }
输出结果:
- new BaseObject!!!!!
- new BaseObject!!!!!
- 池中处于闲置状态的实例pool.getNumIdle():2
- 一级0-------common.keypool.BaseObject@158b649-------1
- 二级0-------common.keypool.BaseObject@127734f-------1
- new BaseObject!!!!!
- 三级0-------common.keypool.BaseObject@1037c71-------1
- 归还对象!!!
- 一级1-------common.keypool.BaseObject@158b649-------2
- 二级1-------common.keypool.BaseObject@127734f-------2
- 三级1-------common.keypool.BaseObject@1037c71-------2
- 归还对象!!!
- 一级2-------common.keypool.BaseObject@158b649-------3
- 二级2-------common.keypool.BaseObject@127734f-------3
- 三级2-------common.keypool.BaseObject@1037c71-------3
- 归还对象!!!
- 一级3-------common.keypool.BaseObject@158b649-------4
- 二级3-------common.keypool.BaseObject@127734f-------4
- 三级3-------common.keypool.BaseObject@1037c71-------4
- new BaseObject!!!!!
- 一级4-------common.keypool.BaseObject@1df073d-------1
- new BaseObject!!!!!
- 二级4-------common.keypool.BaseObject@1546e25-------1
- new BaseObject!!!!!
- 三级4-------common.keypool.BaseObject@b66cc-------1
- 池中所有在用实例pool.getNumActive():6
- 池中处于闲置状态的实例pool.getNumIdle():0
通过输出结果可以看出:
1.对象取出之后可以对对象进行更改,再放回池里这个更改是保留的。
2.池对象的放入和取出默认是后进先出的原则,可以通过池pool的setLifo(boolean lifo)方法设置,默认是true,代表后进先出,设置为false代表先进先出。如果为了池对象使用均衡,推荐使用false。
原文链接:http://blog.youkuaiyun.com/bhy5683/article/details/8776498