java简单对象池

在项目中用到，自己写了个对象池的管理（创建、保留、获取），那种服务器空闲下来再回收的技术。没搞明白是怎么弄得，就没能写出回收部分，还有请求时有队列的管理，我认为这个在并发的程序中用处也不是很大吧，就也没实现。

呵呵，，看下来是不是基本没什么东西啊，，你对了！！！

 

首先，不管池中放多少，先把单个实例及附属方法弄出来,

单个实例中主要的思想

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差距很大啊，不过用还是够了。当然了，这里面肯定有不确定的因素会影响到，比如：效率，安全啊，什么的。。。希望大牛看到能为我指出，我感激不及，真的！