举例讲解Java设计模式中的对象池模式编程

举例讲解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. 定时清理过期的对象。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。