一种轻量级对象池的设计与实现

最新推荐文章于 2024-09-23 09:00:38 发布
最新推荐文章于 2024-09-23 09:00:38 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： cpu/arithmetic/optimize java


一种轻量级对象池的设计与实现

 转自：http://blog.csdn.net/monkey_d_meng/article/details/6267050

       轻量级对象池Java版本的代码已经完成，明早更新博客，讲解设计思路及代码实现，先发个帖子占个位子~

 

=======================我是华丽的分隔线========================

 

好吧，我食言了，拖到现在才交稿，主要是这几天有些事情要处理，一直没来得及写，对不住前几位来访的同志啦~下面言归正转。

创建新对象并初始化的操作，可能会消耗很多时间，特别是当对象初始化的工作包含了大量费时的操作时，在需要大量生成对象的时候，就可能会对性能造成一些不可忽略的影响。要缓解这一问题，除了从底层硬件角度升级考虑之外，同样我们可以从软件层次采取一些必要的减少对象创建次数的编码技巧。恰当使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。因此本文介绍一种轻量级对象池基本的设计与实现思路，参考了开源项目Jakarta Commons Pool的源代码，吸取了其中的精华，改进了一些细节，去除了一些繁杂的逻辑，最终形成了我们自己的一个轻量级的对象池组件，我称之为“OP-ObjectPool1.0”。

我们之前可能会听说过线程池、连接池或IP池等类似的概念。它们的共同特点都是池子里面存放有很多空闲可用的资源，根据具体的请求随需分配资源，请求处理完成则对资源进行回收。当用户请求数大于池中所能提供的资源时，则可考虑对请求进行阻塞以等待资源的回收，或者动态添加新的资源到池中以应对请求。如果我们将池子里面的东东拔高一个层次，不再特指某一个具体的类型，而就是抽象意义上的对象啦，那也就是所谓的对象池啦~

对象池的基本思想是：池中保存了若干的对象，根据请求实现按需分配，用完了就回收，重复使用，从而在一定程度上减少频繁创建对象所造成的开销。这个用户存储、分配和回收对象的容器称之为“对象池”。对于没有状态的对象，在重复使用之前，无需要进行任何处理，对于有状态的对象，在重复使用之前，必须要把它恢复到原始状态。当然在实现过程中，状态恢复应该是依据具体的情况、具体的环境、具体的类型而定的，我们并不能实现统一化的恢复操作，因此将之设计为接口。然而为了方便起见，可以直接将该对象抛弃，返回一个新创建的实例。

注意一个事实：并非所有对象都适合拿来池化à因为维护对象池本身也需要一定的开销。对生成时开销不大的对象进行池化，极可能适得其反出现维护对象池的开销远远大于生成新对象的开销，从而降低性能。看来使用对象池理念上虽然很合乎情理，但是还是要考虑具体的应用场景。

 

一、Jakarta Commons Pool组件简介

Jakarta Commons Pool是一个用于在Java程序中实现对象池化的组件。它的基本情况是：

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

（2）最新版本：1.5.5

（3）所含包数：2个org.apache.commons.pool和org.apache.commons.pool.impl

（4）所含类数：21个（其中有4个抽象类和6个接口）

（5）适用平台：Java 2, Standard Edition.

（6）单纯地使用Pool组件不需要太多的Java 2的知识和经验，对语法和基本概念（对象、异常、类、接口、实例、继承和实现等）有一般了解即可。

（7）Jakarta Commons Pool下载地址： http://jakarta.apache.org/commons/pool

 

二、实现自己的对象池OP-ObjectPool1.0

参照Jakarta Commons Pool的设计思想，我们的对象池组件划分了三类接口：

（1）PoolableObjectFactory：用于管理被池化的对象的产生、恢复和销毁。

（2）ObjectPool：用于管理要被池化对象的借出和归还，并借助PoolableObjectFactory管理对象的产生、恢复和销毁。

（3）ObjectPoolFactory：用于生成大量类型、设置不同的ObjectPool。

OP-ObjectPool1.0的整体代码结构图如下，代码里有详细的注释：

 


三、创立PoolableObjectFactory

对象池组件利用PoolableObjectFactory来管理池化的对象，主要包括对象的产生、恢复和销毁。PoolableObjectFactory是定义的一个抽象接口，在实际使用过程中需要根据情况创建具体实现。

[java]  view plain copy
  1. package com.java.pool;  
  2.   
  3. /** 
  4.  * 池化对象管理工厂接口PoolableObjectFactory：用于管理对象池中对象的创建、还原、销毁 
  5.  *  
  6.  * Email:530025983@qq.com 
  7.  *  
  8.  * @author MONKEY.D.MENG 2011-03-16 
  9.  *  
  10.  */  
  11. public interface PoolableObjectFactory  
  12. {  
  13.     /** 
  14.      * 生成新对象 
  15.      *  
  16.      * @param clsType 
  17.      *            对象类型 
  18.      * @return 新对象 
  19.      */  
  20.     public Object createObject(Class clsType);  
  21.   
  22.     /** 
  23.      * 对象在使用过程中内部状态会发生变化，当归还对象池时可能需要将对象还原为原始状态 
  24.      *  
  25.      * @return 将对象还原为原始状态 
  26.      */  
  27.     public Object clearObject(Object obj);  
  28.   
  29.     /** 
  30.      * 销毁一个对象 
  31.      *  
  32.      * @param obj 
  33.      *            要销毁的对象 
  34.      */  
  35.     public void destroyObject(Object obj);  
  36. }  

四、创立ObjectPool

在有了合适的PoolableObjectFactory之后，便可以开始请出ObjectPool来与之同台演出了。对象池组件本身包含了若干种现成的ObjectPool的实现，可以直接利用。如果觉得不合适，也可以根据实际情况自行创建。具体的创建方法，可以参考下面的源代码。

[java]  view plain copy
  1. package com.java.pool;  
  2.   
  3. /** 
  4.  * 对象池接口ObjectPool：管理对象池中对象的借出、归还等必要的操作 
  5.  *  
  6.  * Email:530025983@qq.com 
  7.  *  
  8.  * @author MONKEY.D.MENG 2011-03-16 
  9.  *  
  10.  */  
  11. public interface ObjectPool  
  12. {  
  13.     /** 
  14.      * 从对象池中取出对象 
  15.      *  
  16.      * @return 取出的对象 
  17.      */  
  18.     public Object borrowObject();  
  19.   
  20.     /** 
  21.      * 将对象返回给对象池 
  22.      *  
  23.      * @param obj 
  24.      *            需要返回的对象 
  25.      */  
  26.     public void returnObject(Object obj);  
  27.   
  28.     /** 
  29.      * 返回当前对象池所申请对象上限数目 
  30.      *  
  31.      * @return 对象上限数目 
  32.      */  
  33.     public int getMaxNum();  
  34.   
  35.     /** 
  36.      * 返回对象池中已经借出的对象数目 
  37.      *  
  38.      * @return 活跃对象数目 
  39.      */  
  40.     public int getActiveNum();  
  41.   
  42.     /** 
  43.      * 返回对象池中空闲的对象数目 
  44.      *  
  45.      * @return 空闲对象数目 
  46.      */  
  47.     public int getIdleNum();  
  48.   
  49.     /** 
  50.      * 清除对象池中所有空闲对象 
  51.      */  
  52.     public void clear();  
  53.   
  54.     /** 
  55.      * 关闭对象池，并释放所占资源 
  56.      */  
  57.     public void close();  
  58.   
  59.     /** 
  60.      * 设置池化对象管理工厂用于管理对象池中的对象 
  61.      *  
  62.      * @param factory 
  63.      *            池化对象管理工厂 
  64.      */  
  65.     public void setFactory(PoolableObjectFactory factory);  
  66. }  

 

五、创立ObjectPoolFactory

有时候，我们想生成类型和设置不同的对象池，就应该考试使用工厂设计模式了，ObjectPoolFactory就应运而生。通过设置不同的参数，调用createPool()方法，ObjectPoolFactory即可生成相应的对象池。

 

[java]  view plain copy
  1. package com.java.pool;  
  2.   
  3. /** 
  4.  * 对象池工厂接口ObjectPoolFactory：采用工厂模式生产对象池 
  5.  *  
  6.  * Email:530025983@qq.com 
  7.  *  
  8.  * @author MONKEY.D.MENG 2011-03-16 
  9.  *  
  10.  */  
  11. public interface ObjectPoolFactory  
  12. {  
  13.     /** 
  14.      * 对象池工厂，用于生成对象池 
  15.      *  
  16.      * @param factory 
  17.      *            池化对象管理工厂 
  18.      * @param maxIdle 
  19.      *            对象池所申请的最大对象数目 
  20.      * @param clsType 
  21.      *            对象类型 
  22.      * @return 
  23.      */  
  24.     public ObjectPool createPool(PoolableObjectFactory factory, int maxNum,  
  25.             Class clsType);  
  26. }  

六、创立基本的实现BasePoolableObjectFactory和BaseObjectPool

PoolableObjectFactory和ObjectPool定义了许多抽象的接口，可以适应不断变化的需求。然而，在大多数的情况下，这些接口可以直接实现，如不进行任何操作或者始终返回true，以节省一些不必要的操作。实现基本的BasePoolableObjectFacoty和BaseObjectPool能够能够简化编码工作。

[java]  view plain copy
  1. package com.java.pool.base;  
  2.   
  3. import com.java.pool.PoolableObjectFactory;  
  4.   
  5. /** 
  6.  * 基础池化对象管理工厂抽象类BasePoolableObjectFactory：提供最基本的池化对象管理操作 
  7.  *  
  8.  * Email:530025983@qq.com 
  9.  *  
  10.  * @author MONKEY.D.MENG 2011-03-16 
  11.  *  
  12.  */  
  13. public abstract class BasePoolableObjectFactory implements  
  14.         PoolableObjectFactory  
  15. {  
  16.     /** 
  17.      * 生成新对象 
  18.      *  
  19.      * @param clsType 
  20.      *            对象类型 
  21.      * @return 新对象 
  22.      */  
  23.     public Object createObject(Class clsType)  
  24.     {  
  25.         try  
  26.         {  
  27.             return clsType.newInstance();  
  28.         }  
  29.         catch (InstantiationException e)  
  30.         {  
  31.             e.printStackTrace();  
  32.         }  
  33.         catch (IllegalAccessException e)  
  34.         {  
  35.             e.printStackTrace();  
  36.         }  
  37.   
  38.         return null;  
  39.     }  
  40.   
  41.     /** 
  42.      * 对象在使用过程中内部状态会发生变化，当归还对象池时可能需要将对象还原为原始状态 
  43.      *  
  44.      * @return 还原后的对象（这里直接创建了一个新对象） 
  45.      */  
  46.     public Object clearObject(Object obj)  
  47.     {  
  48.         obj = null;  
  49.         return new Object();  
  50.     }  
  51.   
  52.     /** 
  53.      * 销毁一个对象 
  54.      *  
  55.      * @param obj 
  56.      *            要销毁的对象 
  57.      */  
  58.     public void destroyObject(Object obj)  
  59.     {  
  60.         obj = null;  
  61.     }  
  62. }  
  63.   
  64. package com.java.pool.base;  
  65.   
  66. import com.java.pool.ObjectPool;  
  67. import com.java.pool.PoolableObjectFactory;  
  68.   
  69. /** 
  70.  * 基础对象池抽象类BaseObjectPool：提供最基本的对象池操作实现 
  71.  *  
  72.  * Email:530025983@qq.com 
  73.  *  
  74.  * @author MONKEY.D.MENG 2011-03-16 
  75.  *  
  76.  */  
  77. public abstract class BaseObjectPool implements ObjectPool  
  78. {  
  79.     /** 对象池是否已经关闭 */  
  80.     private volatile boolean closed = false;  
  81.   
  82.     /** 
  83.      * 返回对象池中空闲对象数目 
  84.      *  
  85.      * @return -1 
  86.      */  
  87.     public int getMaxNum()  
  88.     {  
  89.         return -1;  
  90.     }  
  91.   
  92.     /** 
  93.      * 返回对象池中已借出对象数目 
  94.      *  
  95.      * @return -1 
  96.      */  
  97.     public int getActiveNum()  
  98.     {  
  99.         return -1;  
  100.     }  
  101.   
  102.     /** 
  103.      * 清除对象池中所有空闲对象 
  104.      */  
  105.     public void clear()  
  106.     {  
  107.   
  108.     }  
  109.   
  110.     /** 
  111.      * 关闭对象池，设置状态为关闭 
  112.      */  
  113.     public void close()  
  114.     {  
  115.         closed = true;  
  116.     }  
  117.   
  118.     /** 
  119.      * 设置池化对象管理工厂用于管理对象池中的对象 
  120.      *  
  121.      * @param factory 
  122.      *            池化对象管理工厂 
  123.      */  
  124.     public void setFactory(PoolableObjectFactory factory)  
  125.     {  
  126.   
  127.     }  
  128.   
  129.     /** 
  130.      * 返回对象池是否关闭 
  131.      *  
  132.      * @return 对象池关闭状态 
  133.      */  
  134.     protected final boolean isClosed()  
  135.     {  
  136.         return closed;  
  137.     }  
  138.   
  139.     /** 
  140.      * 断言对象池是否处于开放状态 
  141.      *  
  142.      * @throws IllegalStateException 
  143.      */  
  144.     protected final void assertOpen()  
  145.     {  
  146.         if (isClosed())  
  147.         {  
  148.             throw new IllegalStateException("【对象池处于关闭状态！无法进行相应操作！】");  
  149.         }  
  150.     }  
  151. }  

七、创立各式各样的ObjectPool

对象池组件存储方式应该有很多种：如内存、数据库、文件等；存储的数据结构也可以多种多样：如栈、数组、链表等；存取的策略也可以多种多样：如先进先出FIFO、先进后出FILO等。至于实现可以依据具体情况而定，这里面只简介一种栈存储的StackObjectPool。

[java]  view plain copy
  1. package com.java.pool.impl;  
  2.   
  3. import com.java.pool.ObjectPool;  
  4. import com.java.pool.ObjectPoolFactory;  
  5. import com.java.pool.PoolableObjectFactory;  
  6.   
  7. /** 
  8.  * 栈式对象池工厂类StackObjectPoolFactory：提供生产栈式对象池的工厂 
  9.  *  
  10.  * Email:530025983@qq.com 
  11.  *  
  12.  * @author MONKEY.D.MENG 2011-03-16 
  13.  *  
  14.  */  
  15. public class StackObjectPoolFactory implements ObjectPoolFactory  
  16. {  
  17.     /** 单例 */  
  18.     private static StackObjectPoolFactory instance = null;  
  19.   
  20.     /** 
  21.      * 单例模式 
  22.      *  
  23.      * @return 栈式对象池工厂的单例 
  24.      */  
  25.     public static StackObjectPoolFactory getInstance()  
  26.     {  
  27.         if (null == instance)  
  28.         {  
  29.             instance = new StackObjectPoolFactory();  
  30.         }  
  31.   
  32.         return instance;  
  33.     }  
  34.   
  35.     /** 
  36.      * 栈式对象池工厂，用于生成对象池 
  37.      *  
  38.      * @param factory 
  39.      *            池化对象管理工厂 
  40.      * @param maxIdle 
  41.      *            对象池所申请的最大对象数目 
  42.      * @param clsType 
  43.      *            对象类型 
  44.      * @return 
  45.      */  
  46.     public ObjectPool createPool(PoolableObjectFactory factory, int maxNum,  
  47.             Class clsType)  
  48.     {  
  49.         return new StackObjectPool(factory, maxNum, clsType);  
  50.     }  
  51. }  
  52.   
  53. package com.java.pool.impl;  
  54.   
  55. import java.util.NoSuchElementException;  
  56. import java.util.Stack;  
  57.   
  58. import com.java.pool.ObjectPool;  
  59. import com.java.pool.PoolableObjectFactory;  
  60. import com.java.pool.base.BaseObjectPool;  
  61.   
  62. /** 
  63.  * 栈式对象池类StackObjectPool：提供栈式对象池的操作实现 
  64.  *  
  65.  * Email:530025983@qq.com 
  66.  *  
  67.  * @author MONKEY.D.MENG 2011-03-16 
  68.  *  
  69.  */  
  70. public class StackObjectPool extends BaseObjectPool implements ObjectPool  
  71. {  
  72.     /** 栈式对象池 */  
  73.     protected Stack<Object> pool = null;  
  74.   
  75.     /** 池化对象管理工厂 */  
  76.     protected PoolableObjectFactory factory = null;  
  77.   
  78.     /** 对象池中所存放对象的类型 */  
  79.     private Class clsType = Object.class;  
  80.   
  81.     /** 对象池中所能申请的对象数目上限 */  
  82.     protected int maxNum = 100;  
  83.   
  84.     /** 已借出对象数目 */  
  85.     protected int activeNum = 0;  
  86.   
  87.     /** 
  88.      * 构造函数，构建栈式对象池 
  89.      *  
  90.      * @param factory 
  91.      *            池化对象管理工厂 
  92.      * @param maxIdle 
  93.      *            对象池中空闲对象数目上限 
  94.      * @param initIdleCapacity 
  95.      *            对象池初始化容量 
  96.      */  
  97.     public StackObjectPool(PoolableObjectFactory factory, int maxNum,  
  98.             Class clsType)  
  99.     {  
  100.         this.factory = factory;  
  101.         this.activeNum = 0;  
  102.         this.maxNum = maxNum;  
  103.         this.clsType = clsType;  
  104.         this.pool = new Stack<Object>();  
  105.     }  
  106.   
  107.     /** 
  108.      * 从对象池中取出对象 
  109.      *  
  110.      * @return 取出的对象 
  111.      */  
  112.     public Object borrowObject()  
  113.     {  
  114.         synchronized (pool)  
  115.         {  
  116.             // 断言对象池是否处于开放状态  
  117.             assertOpen();  
  118.   
  119.             Object currentObj = null;  
  120.   
  121.             // 当前对象池有对象可用  
  122.             if (!pool.empty())  
  123.             {  
  124.                 // 直接从对象池中取出对象  
  125.                 currentObj = pool.pop();  
  126.             }  
  127.             // 当前对象池无可用对象  
  128.             else  
  129.             {  
  130.                 // 已借出对象数目小于对象池所要求对象数目最大值  
  131.                 if (activeNum < maxNum)  
  132.                 {  
  133.                     // 池化对象管理工厂为空，则无法生成新对象，抛出异常  
  134.                     if (null == factory)  
  135.                     {  
  136.                         throw new NoSuchElementException();  
  137.                     }  
  138.   
  139.                     // 由池化对象管理工厂生成新对象  
  140.                     currentObj = factory.createObject(clsType);  
  141.   
  142.                     // 生成对象为空则抛出异常  
  143.                     if (null == currentObj)  
  144.                     {  
  145.                         throw new NoSuchElementException(  
  146.                                 "StackObjectPool.borrowObject()返回NULL.");  
  147.                     }  
  148.                 }  
  149.                 // 已借出对象数目到达对象池所要求对象数目最大值  
  150.                 else  
  151.                 {  
  152.                     // 等待其它对象返回对象到池中  
  153.                     try  
  154.                     {  
  155.                         pool.wait();  
  156.                     }  
  157.                     catch (InterruptedException e)  
  158.                     {  
  159.                         e.printStackTrace();  
  160.                     }  
  161.   
  162.                     // 从池中取出对象  
  163.                     currentObj = pool.pop();  
  164.                 }  
  165.             }  
  166.   
  167.             // 增加已借出对象数目  
  168.             ++activeNum;  
  169.   
  170.             return currentObj;  
  171.         }  
  172.     }  
  173.   
  174.     /** 
  175.      * 将对象返回给对象池 
  176.      *  
  177.      * @param obj 
  178.      *            需要返回的对象 
  179.      */  
  180.     public void returnObject(Object obj)  
  181.     {  
  182.         synchronized (pool)  
  183.         {  
  184.             // 断言对象池是否处于开放状态  
  185.             assertOpen();  
  186.   
  187.             // 确保对象具有正确的类型  
  188.             if (obj.getClass() == clsType)  
  189.             {  
  190.                 pool.push(obj);  
  191.   
  192.                 // 减少已借出对象数目  
  193.                 --activeNum;  
  194.   
  195.                 // numActive发生改变，通知其他阻塞线程  
  196.                 pool.notifyAll();  
  197.             }  
  198.             else  
  199.             {  
  200.                 throw new IllegalArgumentException("类型"  
  201.                         + obj.getClass().getName() + "要求类型" + clsType.getName()  
  202.                         + "不匹配！");  
  203.             }  
  204.         }  
  205.     }  
  206.   
  207.     /** 
  208.      * 清除对象池中所有空闲对象 
  209.      */  
  210.     public synchronized void clear()  
  211.     {  
  212.         pool.clear();  
  213.     }  
  214.   
  215.     /** 
  216.      * 关闭对象池，并释放所占资源 
  217.      */  
  218.     public synchronized void close()  
  219.     {  
  220.         super.close();  
  221.         clear();  
  222.   
  223.         pool = null;  
  224.         factory = null;  
  225.         clsType = Object.class;  
  226.         maxNum = -1;  
  227.         activeNum = -1;  
  228.     }  
  229.   
  230.     /** 
  231.      * 返回对象池中已经借出的对象数目 
  232.      *  
  233.      * @return 活跃对象数目 
  234.      */  
  235.     public synchronized int getActiveNum()  
  236.     {  
  237.         return activeNum;  
  238.     }  
  239.   
  240.     /** 
  241.      * 返回当前对象池中可用的空闲对象数目 
  242.      *  
  243.      * @return 空闲对象数目 
  244.      */  
  245.     public synchronized int getMaxNum()  
  246.     {  
  247.         return maxNum;  
  248.     }  
  249.   
  250.     /** 
  251.      * 返回对象池中空闲的对象数目 
  252.      *  
  253.      * @return 空闲对象数目 
  254.      */  
  255.     public synchronized int getIdleNum()  
  256.     {  
  257.         return pool.size();  
  258.     }  
  259.   
  260.     /** 
  261.      * 设置池化对象管理工厂用于管理对象池中的对象 
  262.      *  
  263.      * @param factory 
  264.      *            池化对象管理工厂 
  265.      */  
  266.     public synchronized void setFactory(PoolableObjectFactory factory)  
  267.     {  
  268.         this.factory = factory;  
  269.     }  
  270.   
  271.     public synchronized Stack<Object> getPool()  
  272.     {  
  273.         return pool;  
  274.     }  
  275.   
  276.     public synchronized void setPool(Stack<Object> pool)  
  277.     {  
  278.         this.pool = pool;  
  279.     }  
  280.   
  281.     public synchronized Class getClsType()  
  282.     {  
  283.         return clsType;  
  284.     }  
  285.   
  286.     public synchronized void setClsType(Class clsType)  
  287.     {  
  288.         this.clsType = clsType;  
  289.     }  
  290.   
  291.     public synchronized void setMaxNum(int maxNum)  
  292.     {  
  293.         this.maxNum = maxNum;  
  294.     }  
  295.   
  296.     public synchronized void setActiveNum(int activeNum)  
  297.     {  
  298.         this.activeNum = activeNum;  
  299.     }  
  300.   
  301.     public synchronized PoolableObjectFactory getFactory()  
  302.     {  
  303.         return factory;  
  304.     }  
  305. }  

八、创立String类型的PoolableObjectFactory类

为了对String类型的池化对象进行管理，我们创建了StringPoolableObjectFactory实现PoolableObjectFactory的接口。

[java]  view plain copy
  1. package com.java.pool.impl;  
  2.   
  3. import com.java.pool.base.BasePoolableObjectFactory;  
  4.   
  5. /** 
  6.  * String类型管理工厂类StringPoolableObjectFactory：提供对String类型对象的管理 
  7.  *  
  8.  * Email:530025983@qq.com 
  9.  *  
  10.  * @author MONKEY.D.MENG 2011-03-16 
  11.  *  
  12.  */  
  13. public class StringPoolableObjectFactory extends BasePoolableObjectFactory  
  14. {  
  15.     /** 单例 */  
  16.     private static StringPoolableObjectFactory instance = null;  
  17.   
  18.     /** 
  19.      * 单例模式 
  20.      *  
  21.      * @return 基础池化对象管理工厂的单例 
  22.      */  
  23.     public static StringPoolableObjectFactory getInstance()  
  24.     {  
  25.         if (null == instance)  
  26.         {  
  27.             instance = new StringPoolableObjectFactory();  
  28.         }  
  29.   
  30.         return instance;  
  31.     }  
  32.   
  33.     /** 
  34.      * 对象在使用过程中内部状态会发生变化，当归还对象池时可能需要将对象还原为原始状态 
  35.      *  
  36.      * @return 新对象 
  37.      */  
  38.     public Object clearObject(Object obj)  
  39.     {  
  40.         obj = null;  
  41.         return new String();  
  42.     }  
  43. }  

九、创建测试类

这样，基本上我们就实现了一个轻量级的对象池。还需要对它进行一些测试：

[java]  view plain copy
  1. package com.java.pool.test;  
  2.   
  3. import com.java.pool.ObjectPool;  
  4. import com.java.pool.PoolableObjectFactory;  
  5. import com.java.pool.impl.StackObjectPoolFactory;  
  6. import com.java.pool.impl.StringPoolableObjectFactory;  
  7.   
  8. /** 
  9.  * 对象池测试类Test 
  10.  *  
  11.  * Email:530025983@qq.com 
  12.  *  
  13.  * @author MONKEY.D.MENG 2011-03-16 
  14.  *  
  15.  */  
  16. public class Test  
  17. {  
  18.     public static void main(String[] args)  
  19.     {  
  20.         // 创建String类型的池化对象管理工厂  
  21.         PoolableObjectFactory factory = StringPoolableObjectFactory  
  22.                 .getInstance();  
  23.   
  24.         // 创建栈式对象池  
  25.         ObjectPool pool = StackObjectPoolFactory.getInstance().createPool(  
  26.                 factory, 100, String.class);  
  27.   
  28.         // 多线程测试  
  29.         for (int index = 1; index <= 20; ++index)  
  30.         {  
  31.             new MyThread(pool, factory).start();  
  32.         }  
  33.     }  
  34. }  
  35.   
  36. /** 
  37.  * 封装线程用于测试对象池 
  38.  *  
  39.  * Email:530025983@qq.com 
  40.  *  
  41.  * @author MONKEY.D.MENG 2011-03-16 
  42.  *  
  43.  */  
  44. class MyThread extends Thread  
  45. {  
  46.     /** 对象池 */  
  47.     private ObjectPool pool = null;  
  48.   
  49.     /** 池化对象管理工厂 */  
  50.     private PoolableObjectFactory factory = null;  
  51.   
  52.     /** 
  53.      *  
  54.      * @param pool 
  55.      *            对象池 
  56.      * @param factory 
  57.      *            池化对象管理工厂 
  58.      */  
  59.     public MyThread(ObjectPool pool, PoolableObjectFactory factory)  
  60.     {  
  61.         this.pool = pool;  
  62.         this.factory = factory;  
  63.     }  
  64.   
  65.     public void run()  
  66.     {  
  67.         // 获取新对象  
  68.         String buffer = (String) pool.borrowObject();  
  69.   
  70.         // 必要的业务逻辑神马的  
  71.         buffer = "【" + this.currentThread() + ":MONKEY.D.MENG】-->";  
  72.         System.out.println(buffer + "/t活跃对象数：" + pool.getActiveNum()  
  73.                 + "/t空闲对象数：" + pool.getIdleNum());  
  74.   
  75.         // 返回对象  
  76.         pool.returnObject(factory.clearObject(buffer));  
  77.     }  
  78.   
  79.     public ObjectPool getPool()  
  80.     {  
  81.         return pool;  
  82.     }  
  83.   
  84.     public void setPool(ObjectPool pool)  
  85.     {  
  86.         this.pool = pool;  
  87.     }  
  88.   
  89.     public PoolableObjectFactory getFactory()  
  90.     {  
  91.         return factory;  
  92.     }  
  93.   
  94.     public void setFactory(PoolableObjectFactory factory)  
  95.     {  
  96.         this.factory = factory;  
  97.     }  
  98. }  
  99. 【Thread[Thread-2,5,main]:MONKEY.D.MENG】-->   活跃对象数：2 空闲对象数：0  
  100. 【Thread[Thread-1,5,main]:MONKEY.D.MENG】-->   活跃对象数：2 空闲对象数：1  
  101. 【Thread[Thread-6,5,main]:MONKEY.D.MENG】-->   活跃对象数：4 空闲对象数：0  
  102. 【Thread[Thread-4,5,main]:MONKEY.D.MENG】-->   活跃对象数：3 空闲对象数：0  
  103. 【Thread[Thread-0,5,main]:MONKEY.D.MENG】-->   活跃对象数：2 空闲对象数：1  
  104. 【Thread[Thread-5,5,main]:MONKEY.D.MENG】-->   活跃对象数：3 空闲对象数：1  
  105. 【Thread[Thread-8,5,main]:MONKEY.D.MENG】-->   活跃对象数：3 空闲对象数：2  
  106. 【Thread[Thread-3,5,main]:MONKEY.D.MENG】-->   活跃对象数：3 空闲对象数：1  
  107. 【Thread[Thread-14,5,main]:MONKEY.D.MENG】-->  活跃对象数：3 空闲对象数：1  
  108. 【Thread[Thread-7,5,main]:MONKEY.D.MENG】-->   活跃对象数：2 空闲对象数：2  
  109. 【Thread[Thread-12,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  110. 【Thread[Thread-10,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  111. 【Thread[Thread-9,5,main]:MONKEY.D.MENG】-->   活跃对象数：1 空闲对象数：3  
  112. 【Thread[Thread-11,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  113. 【Thread[Thread-16,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  114. 【Thread[Thread-15,5,main]:MONKEY.D.MENG】-->  活跃对象数：2 空闲对象数：2  
  115. 【Thread[Thread-13,5,main]:MONKEY.D.MENG】-->  活跃对象数：2 空闲对象数：2  
  116. 【Thread[Thread-18,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  117. 【Thread[Thread-17,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  
  118. 【Thread[Thread-19,5,main]:MONKEY.D.MENG】-->  活跃对象数：1 空闲对象数：3  

十、什么时候不要池化

采用对象池化的本意，是要通过减少对象生成的次数，减少花在对象初始化上面的开销，从而提高整体的性能。然而池化处理本身也要付出代价，因此，并非任何情况下都适合采用对象池化。

Dr. Cliff Click在JavaOne 2003上发表的《Performance Myths Exposed》中，给出了一组其它条件都相同时，使用与不使用对象池化技术的实际性能的比较结果。他的实测结果表明：

对于类似Point这样的轻量级对象，进行池化处理后，性能反而下降，因此不宜池化；对于类似Hashtable这样的中量级对象，进行池化处理后，性能基本不变，一般不必池化（池化会使代码变复杂，增大维护的难度）；对于类似JPanel这样的重量级对象，进行池化处理后，性能有所上升，可以考虑池化。

根据使用方法的不同，实际的情况可能与这一测量结果略有出入。在配置较高的机器和技术较强的虚拟机上，不宜池化的对象的范围可能会更大。不过，对于像网络和数据库连接这类重量级的对象来说，目前还是有池化的必要。

基本上，只在重复生成某种对象的操作成为影响性能的关键因素的时候，才适合进行对象池化。如果进行池化所能带来的性能提高并不重要的话，还是不采用对象池化技术，以保持代码的简明，而使用更好的硬件和更棒的虚拟机来提高性能为佳。

 

十一、结束语

恰当地使用对象池化，可以有效地降低频繁生成某些对象所造成的开销，从而提高整体的性能。而借助对象池组件，可以有效地减少花在处理对象池化上的工作量，进而，向其它重要的工作里，投入更多的时间和精力。

000000000000O
关注
专栏目录
C++ 内存池 轻量级实现
10-20
下面将详细介绍内存池的原理、实现方式以及轻量级实现中的关键点。 内存池的基本思想是将内存的申请和释放过程集中管理。通常，系统默认的内存分配器（如C++的`new`和`delete`）在分配小块内存时会有一定的开销，...
对象池的设计及其实现
dukai392的博客
02-23 242
对象池概述：对象池模型创建并拥有固定数量的对象，当程序需要一个新的对象时，如果对象池中有空闲对象，则立即返回，否则才创建新的该类对象。当一个对象不再被使用时，其应该应该将其放回对象池，以便后来的程序使用。由于系统资源有限，一个对象池模型应该指定其可容纳的最大对象数量。当达到该数量时，如果仍然有对象创建请求，则抛出异常或者阻塞当前调用线程，直到一个对象被放回对象池中。 对象池模型适用的场景：(1)需...
【Java设计模式】对象池模式
最新发布
道长的博客
09-23 613
Java中的对象池设计模式管理一组可重用的对象，通过回收对象而不是反复创建和销毁它们来优化内存管理和应用程序性能。
对象池设计的详解以及实现
u012719254的博客
08-14 397
对象池的定义实际使用代码 对象池的定义 对象池模式是单例模式的一个变种，它提供了获取一系列相同对象实例的入口。当你需要对象来代表一组可替代资源的时候就变的很有用，每个对象每次可以被一个组件使用。 在我看来，对象池是用于解决某一常用对象不断创建销毁时造成的大量资源损耗问题。 用筷子举例，如果每次吃饭都需要竹制的筷子，那么每次吃饭之前，你都需要去制作竹筷子；让我们简单一点，制作一些筷子，和一个筷子笼...
设计模式：十五.对象池模式
q493201681的博客
07-20 2535
对象池模式(Object Pool Mode)，是创建模式的一种。本来的五个怎么变成六个了。2333，它和享元模式非常相似，只不过享元模式一个对象可以被多个对象引用，对象池模式一个对象只能被一个对象引用。它是Unity脚本开发中非常常用的模式，对于反复创建销毁的游戏物体使用对象池模式可以大幅提升游戏性能。比如子弹，怪物等等。它和有限状态机一样都有代码框架。这里我也整理了两种对象池代码框架的写法。 ...
轻量级的对象池
cywhoyi的专栏
10-10 110
Pool在N多环境下碰到，比如连接池、线程池、缓存池... 当某一对象从池中取得，那只有等待被用完放回去以后，其它的线程才能再次从池中获取。对象在池中是具有自己生命周期：创建、验证、使用、销毁等等。Pool的方式也许是最好的方式用来管理同一的资源。   运用的场景： 高频率的运用同一的资源 对象大且很消耗内存（DB连接） 需要长时间的初始化 IO消耗大 对象非线程安全   A...
自定义轻量级ORM框架设计与实现
本文档介绍了一个自定义的ORM（对象关系映射）框架的设计和实现，目标是创建一个轻量级且易于使用的框架，简化Java应用与数据库之间的交互。该框架旨在砍掉Hibernate等成熟框架中一些不必要的复杂功能，以提高开发...
cpp-Raft核心算法的一个轻量级C实现可作为一个复制库
08-16
NuRaft 库是这个轻量级 C++ 实现的核心，它包含了以下关键组件： 1. **服务器状态机（Server State Machine）**：每个节点都有一个状态机，用于处理客户端的请求并存储最终一致的状态。 2. **日志（Log）**：存储了...
设计模式之对象池模式（Object Pool）
yangqiang387393的博客
05-19 8754
http://blog.csdn.net/wcyoot/article/details/7584574 http://www.cnblogs.com/west-link/archive/2011/09/05/2167149.html 对象池模式 今天忽然看到一个有趣的设计模式，就上网看了下，现做一个整理。   前期了解：Object Pool，即对象池，对象被预先创建并初始化
设计一个对象池（Anno.XObjectPool）
dym6295的专栏
05-14 265
设计一个.net对象池 对象池对于创建开销比较大的对象来说很有意义，为了优化程序的运行速度、避免频繁创建销毁开销比较大的对象，我们可以通过对象池来复用创建开销大的对象。对象池的思路比较简单，事先创建好一批对象，放到一个集合中，以后每当程序需要新的对象时候，都从对象池里获取，每当程序用完该对象后，都把该对象归还给对象池。这样会避免重复的对象创建，提高程序性能。　 应用场景　 　　在Anno微服务框架中的使用，由于客户端调用微服的时候需要建立Socket连接，频繁的创建和销毁连接会有很大的开...
【案例总结】Unity 对象池设计思路应用
Mr.River的博客
03-30 945
【Unity3D】游戏对象池 前要：   在开发过程中，很多时候会出现针对某一GameObject的频繁创建与销毁这类问题，从性能上认为这种行为是极度损耗的，为避免对性能的不必要损耗，出现[游戏对象池]的优化解决方案。本文将重点讲解[游戏对象池]与相关典型案例进行实战。 原理   Unity中GameObject的创建与销毁依赖于CPU与内存，对于频繁创建和销毁GameObject的行为是十分消耗CPU的性能。为避免CPU不必要的性能开支（负荷），出现以内存为主要对象，预先准备相当的GameObject数量
BasePooledObjectFactory介绍
tsy125的博客
07-05 473
BasePooledObjectFactory线程池
Java对象池pool2分析PooledObjectFactory
qq_37186947的博客
02-08 4944
背景：     池化技术 在Java中使用的相当多了，例如各种数据库连接池，以及JDK自己实现的线程池等等，从根本上说他们都是对象池，把资源池化，按需存取，不仅能够一定程度上节省对象的创建时间(缓存思想)，还能够对池子做一些管理和控制(例如设置资源最大数，闲置数等等)。 池的经典实现要数 apache 的 pool2 了 . Pool2 默认的对...
Jakarta对象池(Commons-pool) (转)
04-24 937
     ☆为什么使用对象池  恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化的框架，以及若干种各具特色的对象池实现      ☆对象池思路    对象池化的基本思路是：将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的
池式结构：对象池（Object Pool）
崔杰城的博客
11-27 2828
对象池：通过重新使用固定的池式结构中的对象，来代替单独分配和释放对象，可以提高程序的性能和内存使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值