【高并发内存池】第一弹之定长内存池

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<time.h>
using std::cout;
using std::endl;

#ifdef _WIN32
	#include<windows.h>
#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)   // 优先把还回来内存块对象，再次重复利用(自由链表)
		{
			obj = (T*)_freeList;
			_freeList = *((void**)_freeList);
		}
		else  
		{
			if (_remainBytes < sizeof(T))  //如果剩余内存字节小于要开的对象大小，则重新申请一块大内存
			{
				_remainBytes = 128 * 1024; // 128k
				_memory = (char*)SystemAlloc(_remainBytes >> 13); //一页内存  //直接系统申请内存，不用malloc
				if(_memory == nullptr)
				{
					throw std::bad_alloc();
				}
			}

			obj = (T*)_memory;
			//如果拿到的空间T，比如说是char 一字节的 都不够放指针 就要开辟个void*的内存，32位为4字节 64为8
			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:
	void* _freeList = nullptr;  //还回来时，自由链表的头指针
	char* _memory = nullptr;   //开辟一块大内存的起始指针
	size_t _remainBytes = 0;   //剩余多少字节
};


struct TreeNode
{
	int _val;
	TreeNode* _left;
	TreeNode* _right;

	TreeNode()
		:_val(0)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

void TestObjectPool()
{
	// 申请释放的轮次
	const size_t Rounds = 5;

	// 每轮申请释放多少次
	const size_t N = 100000;

	std::vector<TreeNode*> v1;
	v1.reserve(N);

	size_t begin1 = clock();
	for (size_t j = 0; j < Rounds; ++j)
	{
		for (int i = 0; i < N; ++i)
		{
			v1.push_back(new TreeNode);
		}
		for (int i = 0; i < N; ++i)
		{
			delete v1[i];
		}
		v1.clear();
	}

	size_t end1 = clock();

	std::vector<TreeNode*> v2;
	v2.reserve(N);

	ObjectPool<TreeNode> TNPool;
	size_t begin2 = clock();
	for (size_t j = 0; j < Rounds; ++j)
	{
		for (int i = 0; i < N; ++i)
		{
			v2.push_back(TNPool.New());
		}
		for (int i = 0; i < N; ++i)
		{
			TNPool.Delete(v2[i]);
		}
		v2.clear();
	}
	size_t end2 = clock();

	cout << "new cost time:" << end1 - begin1 << endl;
	cout << "object pool cost time:" << end2 - begin2 << endl;
}

相关知识点
1.int和size_t的区别？
int在不同架构上都是4字节，size_t在32位和64位架构上分别是4字节和8字节， size_t是无符号整形。

2.条件编译？

#include<iostream>
using namespace std;
#define NYJ
 
int main()
{
#ifdef NYJ
	cout << "ifdef NYJ" << endl;
#else
	cout << "else" << endl;
#endif
}

结果 输出 ifdef NYJ

3. 1281024 >> 13是什么意思？
   求有几页内存 右移一位就等于除2 右移13位等于除以2^13 就是除以8k(81024)
   所以 128*1024 >> 13 等于16
   有16页内存。

4.throw std::bad_alloc();是什么意思？
c++ new开辟新空间失败的话 抛出bad_alloc（）异常

5.  new(obj)T; 是什么意思？
   

这是new定位表达式
作用一般是配合内存池使用，当T，也就是要开辟的空间是一个自定义类型对象的空间时，需要显示调用自定义类型的构造函数。对于新开的空间，返回前都要初始化。
同样的 内存池删除完时也要 obj->~T(); 显示调用析构函数。

6.*((void**)obj) = _freeList;是什么意思??????????????????????? *（int*）obj = _freeList 表示解引用后，取一个int大小内存被赋值成_freeList 同理 *((void**)obj) = _freeList; 表示解引用后，取一个void*大小的内存被赋值成_freeList

7.如下
32位下：
sizeof(int) = 4
sizeof(void*) = 4
64位下:
sizeof(int) = 4;
sizeof(void*) = 8;