在项目中用到,自己写了个对象池的管理(创建、保留、获取),那种服务器空闲下来再回收的技术。没搞明白是怎么弄得,就没能写出回收部分,还有请求时有队列的管理,我认为这个在并发的程序中用处也不是很大吧,就也没实现。
呵呵,,看下来是不是基本没什么东西啊,,你对了!!!
首先,不管池中放多少,先把单个实例及附属方法弄出来,
单个实例中主要的思想
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;
}
}
这个不是很难吧,和Apache下的那个pool差距很大啊,不过用还是够了。当然了,这里面肯定有不确定的因素会影响到,比如:效率,安全啊,什么的。。。希望大牛看到能为我指出,我感激不及,真的!