对象池模式

一、对象池模式

1、定义

对象池模式（Object Pool Pattern）是将对象预先创建并初始化后放入对象池中，对象提供者就能利用已有的对象来处理请求，减少频繁创建对象锁占用的内存空间和初始化时间。属于创建型设计模式。

一个对象池包含一组已经初始化并且可以使用的对象，可以在有需要时创建和销毁对象。

对象池模式就是单例模式加享元模式。

2、结构

（1）模式的结构

主要角色如下：

• 对象池（ObjectPool）：持有对象并提供取/还等方法。
• 抽象池化对象（IPooledObject）：对池中对象的抽象。
• 具体池化对象（ConcretePoolObject）：对池中对象的封装，封装对象的状态和一些其他信息。

3、优缺点

优点：

• 复用池中对象，消除创建对象、回收对象所产生的内存开销、CPU开销等。

缺点：

• 增加了分配/释放对象的开销。
• 很难合理设定对象池的大小。
• 在并发环境中，同步加锁阻塞要比创建对象的开销高数倍。

4、使用场景

• 资源受限的场景。
• 在内存中数量受限的对象。
• 创建成本高的对象，可以考虑池化。

5、在框架源码中使用

• 常见的使用对象池模式的场景有线程池、数据库连接池等。

二、模式的通用实现

代码如下：

public class ObjectPoolPattern {

	public static void main(String[] args) {
		ObjectPool pool = new ObjectPool(3, 5);

		IPooledObject object1 = pool.borrowObject();
		IPooledObject object2 = pool.borrowObject();
		IPooledObject object3 = pool.borrowObject();
		IPooledObject object4 = pool.borrowObject();
		IPooledObject object5 = pool.borrowObject();
		IPooledObject object6 = pool.borrowObject();

		System.out.print(object1 + " --> ");
		object1.operator();
		System.out.print(object2 + " --> ");
		object2.operator();
		System.out.print(object3 + " --> ");
		object3.operator();
		System.out.print(object4 + " --> ");
		object4.operator();
		System.out.print(object5 + " --> ");
		object5.operator();
		System.out.print(object6 + " --> ");
		object6.operator();

		System.out.println("---------归还-------");
		pool.returnObject(object6);
		IPooledObject object7 = pool.borrowObject();
		System.out.print(object7 + " --> ");
		object7.operator();

	}
}

// 对象池（）
class ObjectPool {
	// 当对象不够用时，每次扩容的数量
	private int step = 10;

	private int minCount;
	private int maxCount;

	// 保存未借出的对象
	private Vector<IPooledObject> returned;
	// 保存已经借出的对象
	private Vector<IPooledObject> borrowed;

	public ObjectPool(int minCount, int maxCount) {
		returned = new Vector<>();
		borrowed = new Vector<>();
		this.minCount = minCount;
		this.maxCount = maxCount;

		refresh(this.minCount);
	}

	/**
	 * 初始化一定数量的对象
	 * @param minCount
	 */
	private void refresh(int minCount) {
		for (int i = 0; i < minCount; i++) {
			returned.add(new ConcretePoolObject());
		}
	}

	/**
	 * 借对象
	 * @return
	 */
	public IPooledObject borrowObject(){
		IPooledObject next = null;

		if(returned.size() <=  0){
			int count = maxCount - minCount;
			refresh(count > step ? step : count);
		}

		Iterator<IPooledObject> iterator = returned.iterator();
		while (iterator.hasNext()){
			next = iterator.next();
			returned.remove(next);
			borrowed.add(next);
			break;
		}
		return next;
	}

	public void returnObject(IPooledObject pooledObject){
		returned.add(pooledObject);
		if(borrowed.contains(pooledObject)){
			borrowed.remove(pooledObject);
		}
	}
}

// 抽象池化对象
interface IPooledObject {
	void operator();
}
// 具体池化对象
class ConcretePoolObject implements IPooledObject{
	@Override
	public void operator() {
		System.out.println(" do something");
	}
}

– 求知若饥，虚心若愚。