zoukankan      html  css  js  c++  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是定义的一个抽象接口，在实际使用过程中需要根据情况创建具体实现。

    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的实现，可以直接利用。如果觉得不合适，也可以根据实际情况自行创建。具体的创建方法，可以参考下面的源代码。

    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即可生成相应的对象池。

    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能够能够简化编码工作。

    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。

    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的接口。

    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. }  

    九、创建测试类

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

    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这样的重量级对象，进行池化处理后，性能有所上升，可以考虑池化。

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

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

     

    十一、结束语

    恰当地使用对象池化，可以有效地降低频繁生成某些对象所造成的开销，从而提高整体的性能。而借助对象池组件，可以有效地减少花在处理对象池化上的工作量，进而，向其它重要的工作里，投入更多的时间和精力。
  • 相关阅读:
    拷贝构造函数与赋值函数的区别
    C++模板（一）
    拷贝构造函数
    memcpy函数
    malloc calloc 和 realloc
    extern关键字
    C中不安全函数
    缓冲区溢出问题
    C++引用
    背包问题专栏（01，完全，多重）
  • 原文地址：https://www.cnblogs.com/nafio/p/9137580.html
Copyright © 2011-2022 走看看