C++：开胃菜练习项目---定长内存池的实现以及测试

项目介绍

  简介

  作为学习tcmalloc高并发内存池项目前的一个铺垫。

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

• 先熟悉一下简单内存池是如何控制的
• 作为我们后面内存池的一个基础组件

定长内存池的特点

• 1、固定大小内存申请释放
• 2、性能达到极致(后面有测试)

定长内存池总体分两步

• 申请一段大小一定的内存池memory
• 回收使用后的内存，并在之后可以继续使用

项目实现

1)项目准备

  创建好项目工程后，创建头文件ObjectPool.h。源文件Test.cpp

2)项目封装

  在头文件ObjectPool.h中定义类ObjectPool

  成员变量：

                  char* _memory = nullptr;//指向大块内存的指针所开空间大小
                  size_t remainBytes = 0;//大快内存切分过程中的剩余字节数
                  void* _freeList = nullptr;//还回来过程中链接的自由链表的头指针

2-1)内存申请

这里因为最开始实现内存申请，还未涉及到内存回收，所以这里只是初步实现。

T* New()
{
	T* obj = nullptr;
		//提前开空间 
	//如果剩下的内存不够下一个对象申请 那么就重新开辟空间
		if (remainBytes < sizeof(T))
		{
			_remainBytes = 128 * 1024;
            _memory = (char*)malloc(_remainBytes);
  			if (_memory == nullptr)
			{
				//c++中抛异常的方式
				throw std:: bad_alloc();
			}
		}
		T* obj = (T*)_memory;
		_memory += sizeof(T);
		remainBytes -= sizeof(T);
	return obj;
}

   在申请obj的空间之前，我们的内存已经提前申请好了，在memory中

T*obj=(T*)_memory  则是在memory内存池中申请obj的空间

 2-2)内存回收

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

  这里使用了头插的方法，效率更高，如果采用尾插那时间复杂度就是O(n),效率低。

  这里有点难理解，我拆分成两步来写：

  1、第一次插入

  第一次插入，obj需要指向空

  

 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是C++11 作为新关键字引入的。在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同。在32位机器下大小为4，在64位下大小为8。为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr 。

  此时_freeList指obj，obj又需要指向空nullptr，这是一个难点，因为我们不确定所使用的电脑是32位还是64位，所以obj前4位还是8位存nullptr就需要考虑如何解决，这里最简单的方法就是将obj将转位void **，指向指针的指针，也就是地址，解引用后就是4/8。

2、之后再插入 

  之后就是头插即可，看下图所示：

 2-3)内存的回收利用

  在我们去为obj申请空间时，就可以先检查有没有回收后的内存块，如果有就先使用回收后的，如果没有，就再从memory内存池中申请

T* New()
{
	T* obj = nullptr;
	//如果_freeList不为空，那么先用还回来的
	if (_freeList)
	{
		void* next = *(void**)_freeList;
		obj = _freeList;
		_freeList = next;
	}
	else
	{
		//提前开空间 
	//如果剩下的内存不够下一个对象申请 那么就重新开辟空间
		if (remainBytes < sizeof(T))
		{
			_memory = char(*)malloc(128 * 1024);
			if (_memory == nullptr)
			{
				//c++中抛异常的方式
				throw std:: bad_alloc();
			}
		}
		T* obj = (T*)_memory;
		_memory += sizeof(T);
		remainBytes -= sizeof(T);
		remainBytes -= sizeof(T);
	}
	//定位new，显式调用T的构造函数初始化
	new(obj)T;
	return obj;
}

  此时有个细节需要注意，我们申请好obj的空间后，并没有对其进行初始化，所以此时我们需要定位new，显示调用T的构造函数初始化

  回收也是如此，需要显示调用T的析构函数清理对象

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

3)细节补充

  因为不确定电脑是32位还是64位，因为在回收内存块时，我们的自由链表要求内存块前4/8位存放的是下一个内存块的地址，所以一个内存块的大小是必须大于4/8的。

  所以使用三目运算符来判定，并用void *来修正大小， 

size_t ObjSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
 _memory += ObjSize; 

   所以最终代码为：

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

template<class T>
class ObjectPool
{
public:
	
	T* New()
	{
		T* obj = nullptr;
		//如果_freeList不为空，那么先用还回来的
		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)
				{
					//c++中抛异常的方式
					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;//还回来过程中链接的自由链表的头指针
};

 项目测试

 项目功能

  针对同一类型对象进行内存的申请与回收

 测试用例

  使用vector与我们的定长内存池ObjectPool在内存申请与释放所花费时间方面做对比

  我们会分别在release和debug两个版本下分别对x86(32位)与x64(位)两个不同架构做测试

  测试用例代码

  两个对象在同样的轮次下，每轮申请释放相同的次数，最终进行花费时间对比

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;
}

测试过程

  release版本-x86架构：

 release版本-x64架构： 

 debug版本-x86架构：

 debug版本-x64架构：

测试结果

  通过结果我们可以发现，我们实现的定长内存池无论是在那种版本架构下，都能有着很高效的效率 。

  本文结束，希望可以和大家多多交流。