定义
一个对象池是一组已经初始化过且可以使用的对象的集合，池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非销毁它。
若初始化、实例化的代价高，且有需求需要经常实例化，但每次实例化的数量较少的情况下，使用对象池可以获得显着的效能提升。从池子中取得对象的时间是可预测的，但新建一个实例所需的时间是不确定。
实现
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. 定时清理过期的对象。