内存池的设计思想

内存池简介

内存池是池化技术中的一种形式。通常我们在编写程序的时候回使用 new delete 这些关键字来向操作系统申请内存，而这样造成的后果就是每次申请内存和释放内存的时候，都需要和操作系统的系统调用打交道，从堆中分配所需的内存。如果这样的操作太过频繁，就会找成大量的内存碎片进而降低内存的分配性能，甚至出现内存分配失败的情况。

而内存池就是为了解决这个问题而产生的一种技术。从内存分配的概念上看，内存申请无非就是向内存分配方索要一个指针，当向操作系统申请内存时，操作系统需要进行复杂的内存管理调度之后，才能正确的分配出一个相应的指针。而这个分配的过程中，我们还面临着分配失败的风险。

所以，每一次进行内存分配，就会消耗一次分配内存的时间，设这个时间为 T，那么进行 n 次分配总共消耗的时间就是 nT；如果我们一开始就确定好我们可能需要多少内存，那么在最初的时候就分配好这样的一块内存区域，当我们需要内存的时候，直接从这块已经分配好的内存中使用即可，那么总共需要的分配时间仅仅只有 T。当 n 越大时，节约的时间就越多。

内存池是什么？

内存池是一组资源的集合。程序在申请堆上的内存时，我们可以给它一大块内存（远超出程序要申请的大小，即内存池），并且自己管理，而不是它要多少就从切换到内核态，给它多少。

为什么要设计内存池？

两个原因：
1.因为频繁的new/delete 用户态转内核态，效率低：因为物理内存是一个物理硬件，程序要从物理硬件上申请资源，要调用系统调用，要切换到内核态，还调用驱动······一系列操作；

2.频繁的new/delete可能造成内存碎片。
如何设计？内存池 静态链表 其他类：重载new和delete

如何设计？

内存池：用静态链表实现（静态链表，即用数组描述的链表）；静态链表中基本单位是node结点；如图为6个结点，每个结点的指针域都存放下一个结点的地址，这样这6个结点就连在一起。

node结点有数据域和指针域，数据域为T类型（T为模板），指针域为 node* 类型

其他类需要资源的类：要重载new和delete。即我们的类要重载new和delete，new调用内存池的alloc函数，delete调用内存池的delloc函数。new和delete最终操作的都是结点。

内存池的精髓在于内存池自己管理这些结点：即做好 alloc和delloc 的任务。

内存池申请内存 ：alloc：

内存池归还内存 ：delloc：

如图归还第一个node：

再归还第三个：

你会发现这样设计很是神奇。不管你怎么申请，怎么归还，最终还是这个内存池，妙就妙在结点之间通过结点之间通过指针域连接在一起。

并且这个机制还可以自己扩容。。。并且也不会内存泄漏…后面测试就会发现。

如图内存池用完后：

再申请，就pool指向新的内存块：（之前的会内存泄漏？？？no）

如果再归还之前内存池中的某个node，如图：

来分析代码：

template<typename T>
class Memory_Pool  //内存池
{
public:
	void* alloc(size_t size)   //即申请内存
	{
		if (pool == NULL)   //pool指针为空，说明第一次申请，则申请一个内存池
		{
			pool = (Node*)new char[(size + 4) * 10]();//申请10倍所需资源；+4：数据域后面要加指针域
			Node* pCur = pool;
			for (pCur; pCur < pool + 10 - 1; pCur = pCur + 1)//循环，让每个node的指针域指向下一个node
			{
				pCur->pnext = pCur + 1;
			}
			pCur->pnext = NULL;//最后一个node的next域为NULL
		}
        Node* prt = pool;
		pool = pool->pnext;
		return prt;
	}
 
	void dealloc(void* mptr) //释放内存
	{
		if (mptr == NULL)
			return;
		Node* ptr = (Node*)mptr;
		ptr->pnext = pool;
		pool = ptr;
	}
private:
	class Node    //结点：数据域和指针域
	{
	public:
		Node(T val = T()) :mdata(val), pnext(NULL){}
	public:
		T mdata;    //数据域是一个T类型的数据   设计成模板：多态的体现
		Node* pnext;  //指针域
	};
	static Node* pool;   //设计成static 
    //静态数据成员被当作是类的成员。无论这个类的对象定义了多少个，
    //静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问
};
template<typename T>
typename Memory_Pool<T>::Node* Memory_Pool<T>::pool = NULL;
 
class Test   //一个需要申请堆内存资源的类
{
public:
	Test(int a) :ma(a){}
	void* operator new(size_t size) //重载new
	{
		return mp.alloc(size);//调用内存池pool的申请内存方法 
	}
	void operator delete(void* ptr)  //重载delete
	{
		mp.dealloc(ptr);//调用内存池pool的释放内存方法
	}
private:
	int ma;
	static Memory_Pool<Test> mp;//设计成static 
    //静态数据成员被当作是类的成员。无论这个类的对象定义了多少个，
    //静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问
};
Memory_Pool<Test> Test::mp;
 
int main()
{
	//int* p = new int(10);
	Test* ptest = NULL;
	for (int i = 0; i < 20; i++)
	{
		ptest = new Test(20);
	}
	
	return 0;
}