Java中的对象池模式

Java中的对象池模式

Java对象的生命周期分析：

Java对象的生命周期大致包括三个阶段：

对象的创建，对象的使用， 对象的清除。 因此，对象的生命周期长度可用如下的表达式表示： T = T1 + T2 + T3.其中T1表示对象的创建时间，T2表示对象的使用时间，而T3则表示对象的清除时间。由此，我们可以看出，只有T2是真正有效的时间，而T1,T3则是对象本身的开销。下面再看看T1, T3在对象的整个生命周期中所占的比例。

我们知道，Java对象是通过构造函数来创建的，在这一过程中，该构造函数链中的所有构造函数也都会被自动调用。另外，默认情况下，调用类的构造函数时，Java会把变量初始化成确定的值：所有的对像被设置成null,整数变量(byte, short, int , long)设置成0，float和double变量设置成0.0，逻辑值设置成false,所以用new关键字来新建一个对象的时间开销是很大的，如表1所示。

表1 一些操作所消耗的时间的对照表

运算操作	示例	标准化时间
本地赋值	i = n	1.0
实例赋值	this.i = n	1.2
方法调用	Funct()	5.9
新建对象	New Object()	980
新建数组	New int[10]	3100

从表一可以看出，新建一个对象需要的980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而若新建一个数组所花费的时间就更多了。

再看清除对象的过程。我们知道，Java语言的一个优势，就是Java程序员不需要像C/C++程序员那样，显式地释放对象，而由称为垃圾收集器(Garbage Colletor)的自动内存管理系统，定时或内存凸显不足时，自动回收垃圾对象所占的内存。凡事有利总也有弊，这虽然为Java程序员设计者提供了极大的方便，但同时它也带来了较大的性能开销。这种开销包括两方面：首先是对象管理的开销，GC为了能够正确释放对象，它必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等。其次，在GC开始回收”垃圾”对象时，系统会暂停应用程序的执行，而独占CPU.因此，如果要改善应用程序的性能，一方面应尽量减少创建对象的次数；同时，还应尽量减少T1,T3的时间。而这些均可以通过对象池技术来实现。

对象池技术的基本原理： 对象池技术基本原理的核心有两点：缓存和共享，即对于那些被频繁使用的对象，在使用完后，不立即将它们释放，而是将它们缓存起来，以供后续的应用程序重复使用，从而减少创建对象和释放对象的次数，进而改善应用程序的性能。事实上，由于对象池技术将对象限制在一定的数量，也有效地减少了应用程序在内存上的开销。

实现一个对象池，一般会涉及到如下的类：

⑴对象池工厂(ObjectPoolFactory)类

该类主要用于管理相同类型和设置的对象池(ObjectPool),它一般包含如下两个方法：createPool:用于创建特定类型和设置的对象池；destroyPool:用于释放指定的对象池；

同时为了保证ObjectPoolFactory的单一实例，可以采用Singleton设计模式，见下述getInstance方法的实现：

public synchronized ObjectPoolFactory getInstance() {

if (poolFactory == null) {

poolFactory = new ObjectPoolFactory();

return poolFactory;

}

}

⑵参数对象(ParameterObject)类

该类主要用于封装所创建对象池的一些属性参数，如池中可存放对象的数目的最大值(maxCount)、最小值(minCount)等。

对象池(ObjectPool)类

用于管理要被池化对象的借出和归还，并通知PoolableObjectFactory完成相应的工作。它一般包含如下两个方法：

◆   getObject: 用于从池中借出对象；

◆   returnObject:将池化对象返回到池中，并通知所有处于等待状态的线程；

◆   池化对象工厂(PoolableObjectFactory)类

该类主要负责管理池化对象的生命周期，就简单来说，一般包含对象的创建的创建和销毁。该类同ObjectPoolFactory一样，也可将其实现为单实例。

通用对象池的实现：

对象池的构造和治理可以按照多种方式实现。最灵活的方式是将池化对象的Class类型在对象池之外指定，即在ObjectPoolFactory类创建对象池时，动态指定该对象池所池化对象的Class类型，其实现代码如下：

public ObjectPool createPool(ParameterObject paraObj, Class clsType) {

return new ObjectPool(paraObj, clsType);

}

其中，paraObj参数用于指定对象池对的特征属性，clsType参数则指定了该对象池所存放对象的类型。对象池(ObjectPool)创建以后，下面就是利用它来治理对象了，具体实现如下；

public class ObjectPool {

private ParameteObject paraObj; //该对象池的属性参数对象

private Class clsType; //该对象池中所存放对象得到类型

private int currentNum = 0; //该对象池当前已创建的对象数目

private Object currentObj; //该对象池当前可以

}

package com.test;

public class ObjectPoolFactory {

/**

* 饿汉式单例类

*/

private static final ObjectPoolFactory factory = new ObjectPoolFactory();

/**

* 私有默认的构造子

*/

private ObjectPoolFactory() {

}

/**

* 静态工厂方法

* @return  池工厂

*/

public static ObjectPoolFactory
getInstance() {

return factory;

}

/**

*

* @param paraObj  对象池参数对象

* @param clsType   所创建对象类型

* @return   对象池

*/

public ObjectPool createPool(ParameterObject paraObj, Class clsType) {

return new ObjectPool(paraObj,
clsType);

}

}

package com.test;

import java.util.Vector;

public class ObjectPool {

private ParameterObject paraObj; // 该对象池的属性参数对象

private Class clsType; // 该对象池中所存放对象的类型

private int currentNum =
0; // 该对象池当前已创建的对象数目

private Object currentObj; // 该对象池当前可以借出的对象

private Vector pool; // 用于存放对象的池

public ObjectPool(ParameterObject paraObj, Class clsType) {

this.paraObj = paraObj;

this.clsType = clsType;

pool = new Vector();

}

public Object getObject() {

if (pool.size()
<= paraObj.getMinCount()) {

if (currentNum <= paraObj.getMaxCount())
{ // 如果当前池中无对象可用，

// 而且已创建的对象数目小于所限制的最大值，

// 就利用PoolObjectFactory创建一个新的对象

PoolableObjectFactory objFactory = PoolableObjectFactory

.getInstance();

currentObj = objFactory.createObject(clsType);

currentNum++;

} else {

// 如果当前池中无对象可用，而且所创建的对象数目已达到所限制的最大值，

// 就只能等待其它线程返回对象到池中

synchronized (this)
{

try {

wait();

} catch (InterruptedException e) {

System.out.println(e.getMessage());

e.printStackTrace();

}

currentObj = pool.firstElement();

}

}

} else {

// 如果当前池中有可用的对象，就直接从池中取出对象

currentObj = pool.firstElement();

}

return currentObj;

}

public void returnObject(Object
obj) { // 确保对象具有正确的类型

if (clsType.isInstance(obj))
{

pool.addElement(obj);

synchronized (this)
{

notifyAll();

}

} else {

}

}

}

package com.test;

public class PoolableObjectFactory {

private static PoolableObjectFactory factory;

private PoolableObjectFactory() {

}

public static synchronized PoolableObjectFactory
getInstance() {

if (factory == null)
{

factory = new PoolableObjectFactory();

}

return factory;

}

public Object createObject(Class clsType) {

Object obj = null;

try {

obj = clsType.newInstance();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

return obj;

}

}

package com.test;

public class ParameterObject {

private int MinCount;

private int MaxCount;

public ParameterObject(int MaxCount, int MinCount)
{

this.MaxCount =
MaxCount;

this.MinCount =
MinCount;

}

public int getMinCount()
{

return MinCount;

}

public void setMinCount(int minCount)
{

MinCount = minCount;

}

public int getMaxCount()
{

return MaxCount;

}

public void setMaxCount(int maxCount)
{

MaxCount = maxCount;

}

}

package com.test;

public class TestPool {

public static void main(String[]
args) {

ObjectPoolFactory poolFactory = ObjectPoolFactory.getInstance();

ParameterObject paraObj = new ParameterObject(2,1);

ObjectPool pool = poolFactory.createPool(paraObj, StringBuffer.class);

StringBuffer buffer = (StringBuffer)pool.getObject();

buffer.append("hello");

System.out.println(buffer.toString());

}

}

String中的对象池模式：我们知道得到String对象有两种办法：String str1=”hello”;String str2=new String(“hello”);那么这两种创建String对象的方法有什么差异吗？当然有差异，差异在于第一种方法在对象池中拿对象，第二种方法直接生成新的对象。在JDK5.0里面，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象。当我们在程序中直接用双引号括起来一个字符串是，JVM就到String的对象池里面去找看是否有一个值相同的对象，如果有，就拿现成的对象，如果没有就在对象池里创建一个对象，并返回。所以我们发现下面的代码输出true:
String str1=”hello” ;String str2=”hello”;

System.out.println(str1==str2);这说明str1和str2指向同一个对象，因为它们都是在对象池中拿到的，而下面的代码输出为false;因为在任何情况下，只要你去new一个String对象那都是创建了新的对象。与此类似的，在JDK5.0里面8中基本类型的包装类也有这样的差异：Interger i1=5; 在对象池中拿到Integer i2=5;所以i1==i2 Integer i3= new Integer(5); //重新创建对象，所以i2
!= i3对象池的存在是为了避免频繁的创建和销毁对象的而影响系统性能，那我们自己写的类是否也可以使用对象池呢？当然可以，考察下面的代码：

package com.test;

import java.util.HashSet;

import java.util.Set;

class Student {

private int id;

private String name;

private static Set<Student> students = new HashSet<Student>();

public Student(int id,
String name) {

this.id = id;

this.name = name;

}

public static Student
getInstance(int id, String name) {

for (Student st : students)
{

if (id == st.id  &&
name.equals(st.name)) {

return st;

}

}

Student temp = new Student(id, name);

students.add(temp);

return temp;

}

}

public class Test4 {

public static void main(String[]
args) {

Student st1 = Student.getInstance(0, "liyangbing");

Student st2 = Student.getInstance(0, "liyangbing");

System.out.println("s1 == s2 is " +
(st1 == st2)); //对象st2是从对象池中取得，故str1 == str2

Student st3 = new Student(0, "liyangbing");

Student st4 = new Student(0, "liyangbing");

System.out.println("st3 == st4 is " +
(st3 == st4)); //对象st3和st4都是创建的,故st3
!= st4

}

Java曾经号称是纯面向对象的语言，那么我们经常用的8中基本数据类型算不算对象呢？答案很肯定不算，那么java又怎能称得上是纯面向对像的语言呢？为此，SUN公司特意的推出了8中基本数据类型的包装类，这样java语言才算是称得上纯面向对象的语言，那么在JDK中就有9个对象池，8个基本类包装类对象和String类对象。请注意：在J2ME里面没有对象池的概念。

结束语：

恰当地使用对象池技术，能有效地改善应用程序的性能。目前，对象池技术已得到广泛的应用，如对于网络和数据库连接这类重量级的对象，一般都会采用对象池技术。但在使用对象池技术时也要注意如下问题：

并非任何情况下都适合采用对象池技术，基本上，只在重复生成某种对象的操作成为影响性能的关键因素的时候，才适合采用对象池技术。而如果进行池化所带来的性能提高并不重要的话，还是不采用对象池技术为佳，以保持代码的简明。

要根据具体情况正确选择对象池的实现方式。如果是创建一个公用的对象池技术实现包，或需要在程序中动态指定所池化对象的Class类型时，才选择通用对象池，而大部分情况下，采用专用对象池就可以了。

public class ObjectPool {

　private ParameterObject paraObj;//该对象池的属性参数对象

　private int currentNum = 0; //该对象池当前已创建的对象数目

　private StringBuffer currentObj;//该对象池当前可以借出的对象

　private Vector pool;//用于存放对象的池

　public ObjectPool(ParameterObject paraObj) {

　　this.paraObj = paraObj;

　　pool = new Vector();

　}

　public StringBuffer getObject() {

　　if (pool.size() <= paraObj.getMinCount()) {

　　　if (currentNum <= paraObj.getMaxCount()) {

　　　　currentObj = new StringBuffer();

　　　　currentNum++;

　　　} 

　　　. . . 

　　}

　　return currentObj;

　}

　public void returnObject(Object obj) {

　　// 确保对象具有正确的类型

　　if (StringBuffer.isInstance(obj)) {

　　　. . . 

　　}

　}