对象池的解释与剖析

1.对象池的概念

所谓对象池，就是一个池子里面放了指定数量的对象（在代码实现过程中使用链表将指定数量的对象串起来），我们需要使用的时候直接从池子中取出对象，使用完毕之后将对象还给池子，这个过程并不需要调用者创建对象或者销毁对象。

对象池被较多的应用于游戏开发的场景中，比如在制作子d射击的时候，每一次射击的子d都被new出这样一个对象，消耗内存资源，当子d射击到对应的物体上，在屏幕中不需要显示子d了，（这个过程所需的时间往往很短），所以就需要再次释放，这样短时间内不断重复地创建和析构对象会使得程序的效率很低并且耗费内存资源。所以使用对象池，子d被发出去就对应的从对象池中获取一个对象，子d从屏幕上消失对应的将这个对象还给池子，岂不快哉！

2.对象池的使用场景

（1）资源受限的情况：在“CPU性能不强、内存紧张、垃圾回收会造成较大影响”等情况下，需要提高内存管理效率。
例如：
①需要大量存活期短且初始化成本低的对象，使用对象池降低内存分配和再分配成本，减少内存碎片
②对象以固定的速度不断分配，垃圾收集时间逐步增加，内存使用率不断增大
③对象分配存在爆发期，每次爆发都会导致系统迟滞，并有明显的垃圾回收中断
（2）对象的初始化成本非常高，或者对象过大，建立起来较为复杂。

3.对象池的优、缺点

（1）优点：
可以重复利用对象池中的对象，避免创建对象以及销毁对象时对内存以及CPU、网络所产生的开销，可以缓解资源首先的压力
（2）缺点：
①多线程并发的情况下，需要对获取池中的对象这一资源进行多线程的同步处理，此外如果对锁处理不当发生死锁等阻塞问题，会比创建对象和销毁对象更为麻烦
②对象池中对象的数量有所限制，因为是开发人员自己规定的，所以设置合适的对象数量比较难，往往较小数量的对象并不能起到对象池应发挥的作用，但是较大的数量会占用较大的内存资源。

4.对象池的设计 4.1设计原理：

对象池就是从内存中申请一大块空间，然后在这个内存空间中构建一个个对象，分别占中一小块空间。用的时候获取这一小块空间，不用的时候还给对象池。不需要调用的时候再次向系统申请空间。不同类型的对象池是相互独立存在的。

4.2相关设计概念：

关于对象池设计的详细概念问题请见下面的博客：
一个广为人知但鲜有人用的技巧：对象池

对其我简要总结如下：
（1）对象池的两种基本的回收模式：
①借用：调用者通过相应的接口函数申请对象，不需要的时候返回对象（缺点：不能用于对象被多个线程同步访问的情况。优点：不知道对象池的存在）
②引用计数：每个对象持有一个内部计数器和一个指向池的引用，引用计数器为0，对象返回池中。（缺点：实现起来较借用的方式稍微复杂一些。优点：可用于多个线程同步访问的情况）
（2）对象池的三种分配触发方式：
①空池触发：对象池空了就分配对象。
②水位线：对象池中对象的数量小于规定值就分配对象。
③lease/return速度：获取对象的速度大于返回对象的速度，就需要分配对象。
（3）增长策略：
固定大小
小步增长
块增长

4.3对象池设计代码：

#include 
using namespace std;
//对象池：
template<class _Ty>
class ObjectPool
{
private:
	enum { nPoolSize = 4};
protected:
	struct _Node
	{
		_Node* next;
	};
	_Node* front;
	_Node* rear;
	void ReFillPool() //填充对象池
	{
		int total = sizeof(_Node) + sizeof(_Ty);
		//在内存中构建四个对象，并把这四个对象初始化好，用的时候直接从对象池中拿
		for (int i = 0; i < nPoolSize; ++i)
		{
			_Node* s = (_Node*)malloc(total);
			s->next = nullptr;
			new(s + 1) _Ty();//通过定位new在结点s的对象部分构建一个对象
			rear->next = s;
			rear = s;
		}
	}
	void InitPool() //初始化对象池
	{
		_Node* s = (_Node*)malloc(sizeof(_Node));
		s->next = nullptr;
		front = rear = s;
		ReFillPool();//填充对象池
	}
	void Clear()   //清除对象池
	{
		_Node* p = nullptr;
		while (front->next != nullptr)
		{
			p = front->next;
			front->next = p->next;
			free(p);
		}
		free(front);
		front = rear = nullptr;
	}
	ObjectPool(const ObjectPool&) = delete;
	ObjectPool& operator=(const ObjectPool&) = delete;
public:
	ObjectPool() :front(nullptr), rear(nullptr)
	{
		InitPool();
	}
	~ObjectPool()
	{
		Clear();
	}
	_Ty* allocObjMemory()//从线程池获取一个对象
	{
		if (front = rear)
		{
			ReFillPool();
		}
		_Node* s = front->next;
		front->next = s->next;
		if (s == rear)
		{
			rear = front;
		}
		return (_Ty*)((char*)s + sizeof(_Node));//这里加了sizeof(_Node)主要是返回一个线程，并不需要返回next指针
	}
	void freeObjMemory(void* q)//释放一个对象并将这个对象还给内存池
	{
		_Node* p = (_Node*)((char*)q - sizeof(_Node));
		p->next = nullptr;
		rear->next = p;
		rear = p;
	}
};
//通过ObjectPoolBase对象的函数从对象池中获取对象以及将对象还给池子
template<class _Ty>
class ObjectPoolBase//单例模式
{
public:
	void* operator new(size_t size)
	{
		return objpool.allocObjMemory();
	}
	void operator delete(void* p)
	{
		objpool.freeObjMemory(p);
	}
	_Ty* GetObject()
	{
		return objpool.allocObjMemory();
	}
	void RetObject(_Ty* p)
	{
		objpool.freeObjMemory(p);
	}

	static ObjectPoolBase<_Ty>& instance()
	{
		static ObjectPoolBase<_Ty> objbase;
		return objbase;
	}
private:
	using ClassTypePool = ObjectPool<_Ty>;
	ClassTypePool objpool;
};
//创建一个Point类
class Point
{
private:
	float _x;
	float _y;
public:
	Point(float x = 0.0f, float y = 0.0f) :_x(x), _y(y) {}
	Point(const Point&) = default;
	Point& operator=(const Point&) = default;
	~Point() {} 
public:
	void* operator new(size_t) = delete;
	void operator delete(void*) = delete;
};
int main()
{
	ObjectPoolBase<Point>& pointpool = ObjectPoolBase<Point>::instance();
	Point* ap = pointpool.GetObject();
}