举例讲解Java设计模式中的对象池模式编程
作者：lixiang0522
这篇文章主要介绍了Java设计模式中的对象池模式编程示例分享,对象池模式经常在多线程开发时被用到,需要的朋友可以参考下
定义
一个对象池是一组已经初始化过且可以使用的对象的集合，池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非销毁它。
若初始化、实例化的代价高，且有需求需要经常实例化，但每次实例化的数量较少的情况下，使用对象池可以获得显著的效能提升。从池子中取得对象的时间是可预测的，但新建一个实例所需的时间是不确定。
实现
1. Reusable - 对象池中的对象，通常实例化代价比较高。
2. Client - 使用一个对象的实例。
3. ReusablePool - 管理对象的实例化，回收和销毁。
单个实例中主要的思想
1.一个栈，这里用stack
2.初始化方法，容器开启的时候可以预先创建池
3.创建实例的方法
4.提供从池中获得对象实例的方法
5.提供返回的方法,不返回后果很严重
6.控制请求等待时间的方法，过了一定的事件还没获得对象实例，就返回一个null指针
import java.util.Stack;
@SuppressWarnings("unchecked")
public class ObjectPool {
public ObjectPool() {
}
private PoolParam poolParam;
public void setPoolParam(PoolParam poolParam) {
this.poolParam = poolParam;
}
// 当前总对象个数
private int currentNum = 0;
private Class clazz;
public void setClazz(Class clazz) {
this.clazz = clazz;
}
// 栈，用来存放对象，模拟一个池
private Stack stack;
public Stack getStack() {
return stack;
}
public void setStack(Stack stack) {
this.stack = stack;
}
// .................................................................
// 等待超时的记数变量
private int timeWait = 0;
// .................................................................
// 创建对象池
public void initalPool(PoolParam poolParam, Class clazz) {
this.setPoolParam(poolParam);
this.setClazz(clazz);
stack = new Stack();
stack.clear();
// System.out.println("obj..pool is initial...");
// 生成配置最小对象数，并压入栈中
try {
for (int i = 0; i < poolParam.getMinObjectCount(); i++) {
// 根据poolParam初始化对象池
stack.push(clazz.newInstance());
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
// 创建单个对象
private Object createObj(Class clazz) {
Object obj = null;
try {
obj = clazz.newInstance();
// System.out.println("a new one...");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
// 对象池提供的get方法
public Object getInstance(){
// System.out.println(stack.size());
Object object = null;
if (stack.size() == 0) {
// 如果当前栈的长度为0，并且总的对象数没有超过定义最大数
if ((currentNum + poolParam.getMinObjectCount()) < poolParam
.getMaxObjectCount()) {
// 新创建一个对象
object = this.createObj(clazz);
// 对象数+1
currentNum++;
} else {
synchronized (this) {
try {
waitme(this);
} catch (Exception e) {
e.printStackTrace();
}
// 获得通知后检测栈中是为空，并给出刚刚释放的资源
if (!stack.empty()) {
object = stack.pop();
}
}
}
} else if (stack.size() > 0) {
object = stack.pop();
// System.out.println(stack.size());
}
return object;
}
// 返回对象的方法
public void returnObj(Object obj) {
if (clazz.isInstance(obj)) {
stack.push(obj);
synchronized (this) {
notify();
}
} else {
System.out.println("this object can not push to stack!");
}
}
// 等待递归算法
private void waitme(ObjectPool pool) {
// 等待2s的技术控制
if (timeWait >= 2000) {
System.out.println("jump up this step..");
timeWait = 0;
return;
} else {
try {
pool.wait(500);
// 等待计数累加。。
timeWait +=1000;
System.out.println("waiting time to free obj..");
if (stack.empty()) {
System.out.println("agian....");
waitme(pool);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
管理池类，这个不是很难，同步了就好
@SuppressWarnings("unchecked")
public class ObjectPoolManage {
private ObjectPoolManage() {
}
private static ObjectPool pool;
// 实现一个单例的获取方法....默认
public static synchronized ObjectPool getCacheObject(Class clazz) {
if (null != pool) {
return pool;
} else {
createObjectPool(null, clazz);
return pool;
}
}
// 实现一个单例的获取方法...自定义
public static synchronized ObjectPool getCacheObject(PoolParam p, Class clazz) {
if (null != pool) {
return pool;
} else {
createObjectPool(p, clazz);
return pool;
}
}
private static ObjectPool createObjectPool(PoolParam p, Class clazz) {
pool = new ObjectPool();
if (null == p) {
pool.initalPool(new PoolParam(5,10), clazz);
} else {
pool.initalPool(p, clazz);
}
return pool;
}
private static Class getclazz(){
Class clazz=null;
try {
clazz= Class.forName(ppp.getPropertyByName("objectPath"));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return clazz;
}
}
相关问题和实现
1. 对象池中可以限制对象的个数，当超过限制时，对象池需要返回异常或者空值，以通知客户。
2. 在多线程环境中，在checkout和checkin方法需要同步。
3. 定时清理过期的对象。