【lesson2】定长内存池的实现

介绍

作为程序员(C/C++)我们知道申请内存使用的是malloc，malloc其实就是一个通用的大众货，什么场景下都可以用，但是什么场景下都可以用就意味着什么场景下都不会有很高的性能，下面我们就先来设计一个定长内存池做个开胃菜，当然这个定长内存池在我们后面的高并发内存池中也是有价值的，所以学习他目的有两层，先熟悉一下简单内存池是如何控制的，第二他会作为我们后面内存池的一个基础组件。

定长内存池的设计

首先定长内存池的设计我们会向内存申请一大块空间，那么这么一大块空间我们肯定的知道在哪里，所以就用_memory指针指向该块空间：

我们需要定义对象时，我们就只需要向内存池中的_memory申请一个对象大小的字节数就行了。

我们被申请出去了一个或者多个对象大小的空间，那么一定会被还回来，所以我们就要对这些还回来的对象空间进行管理。
所以我们需要将这些还回来的对象，用单向链表管理起来。

那么我们是如何用_freeList把一个一个对象链接起来的呢？
我们可以用一个对象的前几个字节来存储下一个对象的地址。

定长内存池的实现

需要成员变量

在实现定长内存池之前我们要想，定长内存池需要哪些成员变量？

首先：我们向系统堆申请一定大小的空间，那么我们肯定要知道这块空间在哪里，所以第一个成员变量就是_memory指针，指向我们向系统申请的堆空间。
1._memory指针

其次：我们申请了对象就一定会被还回来，所以就要管理还回来的对象，所以第二个成员变量就是_freeList指针。
2._freeList指针

最后：我们_memory指向申请的堆空间如果一直被申请的话，那么申请的堆空间就一定会被使用殆尽，这时就需要向系统申请新的堆空间，那么我们该如何知道申请的堆空间是否被使用使用殆尽。所以就需要第三个成员变量_remainBytes记录剩余空间
3._remainBytes

需要的成员函数

除了成员变量我们还需要想定长内存池需要哪些成员函数？

首先：我们肯定需要一个成员函数，来为我们提供申请一个对象大小空间的窗口。
跟C++申请空间一样命名为New（）。

最后：我们申请了一个对象大小的空间，那么最后肯定是要释放的，所以我们肯定要需要一个函数，来为我们提供释放空间的窗口。
跟C++释放空间一样命名为Delete（）。

定长内存池结构

定长内存池Delete（释放空间）的实现

Delete函数的逻辑很简单，我们只要把释放回来的对象空间，链接到_freeList即可，所以我们先实现Delete函数。

但是Delete我们也遇到了一个难题，还回来的是一个对象大小的空间啊，并不是一个对象啊。
那么我们如何把一个对象大小的空间链接到_freeList中呢？
这时我们就可以想到，我们可以一个对象大小空间的前4个字节存储指针的大小。

但是这时又遇到了一个问题，这个代码在32位平台下是可以的，但是在64位平台下指针是8个字节的该代码就不行了。
这时项目的高手就想到了一个办法。


(void**)在32位下解引用*(void**)是一个指针的指针，大小是4个字节。
(void**)在64位下解引用*(void**)也是一个指针的指针，大小是8个字节。

这时我们的问题就迎刃而解。

Delete函数的实现：

void Delete(T* obj)
	{
		// 头插
		*(void**)obj = _freeList;
		_freeList = obj;
	}

定长内存池New（申请空间）的实现

New申请空间的步骤：
1.先查看_freeList是否有空闲的一个对象大小的空间，我们优先把还回来内存块对象，再次重复利用。

if (_freeList)
{
	void* next = *((void**)_freeList);
	obj = (T*)_freeList;
	_freeList = next;
}

2.如果_freeList没有空闲的对象空间，那么就向_memory要一块，对象大小的空间。
但是要的时候我们还得注意_memory指向的系统堆空间是否已经使用殆尽了？
如果已经使用殆尽了，我们得先向系统申请一块大的堆空间。
那么如何判断空间是否已经使用殆尽呢？

// 剩余内存不够一个对象大小时，则重新开大块空间
if (_remainBytes < sizeof(T))
{
	_remainBytes = 128 * 1024;//自己规定的向系统堆空间申请的空间大小
	//_memory = (char*)malloc(_remainBytes);
	_memory = (char*)SystemAlloc(_remainBytes >> 13);//Windows下脱离malloc申请大块空间
	if (_memory == nullptr)
	{
		throw std::bad_alloc();
	}
}

这下我们就不考虑_memory指向的系统堆空间是否已经使用殆尽的问题了。
那么我们接下里就要向_memory要一个对象大小的空间。
那么如何要呢？
首先让obj指针_memory的首地址。

然后_memory += objSize，也就是_memory += 一个对象的大小。

这里大小可能也就明白了，为什么要把_memory定义成char的，因为char容易控制。

然后我们把obj初始化，然后返给外层就可以了。

obj = (T*)_memory;//先把_memory的地址给obj
//然后计算要多少大小的空间，申请的空间大小 > 一个指针的大小 则用一个对象大小
//如果申请的空间大小 < 一个指针的大小 就用一个指针的大小
//因为我们要用对象的前几个字节存储地址，所以一个对象的大小必须 >= 一个指针
size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
_memory += objSize;
_remainBytes -= objSize;

New函数的实现：

T* New()
	{
		T* obj = nullptr;

		// 优先把还回来内存块对象，再次重复利用
		if (_freeList)
		{
			void* next = *((void**)_freeList);
			obj = (T*)_freeList;
			_freeList = next;
		}
		else
		{
			// 剩余内存不够一个对象大小时，则重新开大块空间
			if (_remainBytes < sizeof(T))
			{
				_remainBytes = 128 * 1024;
				//_memory = (char*)malloc(_remainBytes);
				_memory = (char*)SystemAlloc(_remainBytes >> 13);
				if (_memory == nullptr)
				{
					throw std::bad_alloc();
				}
			}

			obj = (T*)_memory;
			size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
			_memory += objSize;
			_remainBytes -= objSize;
		}

		// 定位new，显示调用T的构造函数初始化
		new(obj)T;

		return obj;
	}

定长内存池的实现完整版

#pragma once
#include 
#include 
#include 
using std::cout;
using std::endl;

#ifdef _WIN32
#include
#else
// 
#endif

// 直接去堆上按页申请空间
inline static void* SystemAlloc(size_t kpage)
{
#ifdef _WIN32
	void* ptr = VirtualAlloc(0, kpage << 13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#else
	// linux下brk mmap等
#endif

	if (ptr == nullptr)
		throw std::bad_alloc();

	return ptr;
}

template<class T>
class ObjectPool
{
public:
	T* New()
	{
		T* obj = nullptr;

		// 优先把还回来内存块对象，再次重复利用
		if (_freeList)
		{
			void* next = *((void**)_freeList);
			obj = (T*)_freeList;
			_freeList = next;
		}
		else
		{
			// 剩余内存不够一个对象大小时，则重新开大块空间
			if (_remainBytes < sizeof(T))
			{
				_remainBytes = 128 * 1024;
				//_memory = (char*)malloc(_remainBytes);
				_memory = (char*)SystemAlloc(_remainBytes >> 13);
				if (_memory == nullptr)
				{
					throw std::bad_alloc();
				}
			}

			obj = (T*)_memory;
			size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
			_memory += objSize;
			_remainBytes -= objSize;
		}

		// 定位new，显示调用T的构造函数初始化
		new(obj)T;

		return obj;
	}

	void Delete(T* obj)
	{
		// 显示调用析构函数清理对象
		obj->~T();

		// 头插
		*(void**)obj = _freeList;
		_freeList = obj;
	}

private:
	char* _memory = nullptr; // 指向大块内存的指针
	size_t _remainBytes = 0; // 大块内存在切分过程中剩余字节数

	void* _freeList = nullptr; // 还回来过程中链接的自由链表的头指针
};