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