设计定长的内存池

感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言
🐔🐔🐔 C++
🐿️🐿️🐿️ 文章链接目录
🤠🤠🤠 高并发内存池项目

定长内存池设计

设计思路

申请一大块内存,用一个指针指向申请的内存,这里的难点是内存释放,因为我们申请的是一块很大的内存,而使用的时候都是将这一大块内存切成一小块一小块的用,而用完后释放我们不可以直接将他还给系统,因为释放的内存太小了,如果还给系统就会出现内存碎片的问题,所以我们是要将需要释放的内存管理起来,当他们都释放后再归还内存,这里的管理方式就是用一个链表将内存管理起来

由于是定长内存池,这里的定长就是切固定大小的内存

具体实现

定长内存池初始化

首先我们需要一个类

class Objectpool
{};

由于是定长内存池,所以类里面一点要有一个指针指向申请的内存空间,为了方便切割内存我们使用char*_memory,因为char是可以精确到1个字节1个字节的切割比较方便,如果是int的话那么我们要切割的长度就是4的倍数
此外因为申请内存是固定的我们可以用非类型的模版参数template<size_t N>表示我们申请的内存是一个固定大小为N
当然我们也可以用template表示ObjectPool每次获取的对象都是一个T对象,T的大小是固定的,这里我们选择的是用template

template<class T>
class ObjectPool
{char* _memory=nullptr;
};

我们还需要考虑内存回收

当我们需要切割内存时_memory需要往后移动

当切割后的内存用完后需要回收我们需要用一个链表将他们串起来


可是现在有一个问题我们应该怎么样才能将他们串起来,我们是否需要再定义一个结构体将他们链接起来呢?

其实是不需要的,我们可以直接在内存当中修改,将后面的内存块地址存到前一个内存块当中,但是这里有一个要求就是32位下的指针大小是4个字节,而64位下的指针大小是8个字节,也就意味着当我们要存一个内存块的空间时,32位下内存块至少要有4个字节,而64位则至少要有8个字节

在32位下对于一个内存块有100字节我们则需要将他的头4个字节进行修改保存下一块内存的地址

T*New()申请内存

申请内存我们需要先看_memory是否为空,如果_memory为空的话那么就需要申请内存

T* New()
{if (_memory==nullptr)//剩余内存不够一个对象大小是重新开大块空间{_memory =(char*) malloc(128 * 1024);//128kbif (_memory == nullptr){throw std::bad_alloc();}}T* obj = (T*)_memory;_memory += sizeof(T);return obj;
}

如果申请后_memory仍为空那么就抛异常,反之就让一个对象obj指向申请内存的空间
_memory += sizeof(T)就表示的切割空间,让_memory切割 sizeof(T)大小的空间

这里有一个问题就是_memory走到最后的时候,如果_memory继续+= sizeof(T)就会造成越界,因为申请的内存以及用完了,而_memory现在在访问的是别的空间


为了解决这个问题我们还需要有一个remainBytes去记录还剩多少空间,当remainBytes<sizeof(T)的时候就意味着剩下的空间以及不足以支持我们继续切割了,可能需要重新申请一块空间

为什么是可能需要重新申请一块空间呢,因为_freeList是回收释放的内存,如果_freeList中有回收了的内存,那么这些内存是可以继续重复利用的
所以一开始需要一个指针next保存_freeList前面记录下来的位置,然后让obj指向_freeList,再让_freeList=next

	T* obj = nullptr;if (_freeList){void* next = *((void**))_freeList);obj = (T*)_freeList;//因为obj是T*,所以_freeList也要强转_freeList = next;}

void* next = * ((void**))_freeList)这段代码会在下面部分解释



还有一个问题就是sizeof(T)大小问题,因为这是一个类模版,如果T是char类型的话他的内存是小于4个字节的,int类型的话也就刚好4个字节,但是在64位下是不够的,所以需要判断sizeof(T) < sizeof(void*) ,表示T的内存大小是否小于一个指针,如果小于的话就要更改切割内存的大小
最后我们还需要对我们创造的对象进行初始化
这里用定位new显示调用T的构造函数初始化new(obj)T

代码

	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);//128kbif (_memory == nullptr){throw std::bad_alloc();}}obj = (T*)_memory;size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);//因为T是一个类模版,当T是char或int时可能会导致内存不足以存储一个地址_memory += objSize;_remainBytes -= objSize;}new(obj)T;//定位new显示调用T的构造函数初始化return obj;}

void Delete(T* obj)回收内存

在最开始的时候_freeList是指向的空

当第一次有空间回收时,我们要让空间的前4个字节存空地址,具体办法就是让传入的指针强转成int*,那么我们对int进行解引用将前4个字节更改为nullptr就可以实现了

但是这里有一个问题就是int只有4个字节,这种方法只适用于32位下,在64位下是不行的
当然我们可以用if语句判断一个指针的大小,然后再进行细分也是可以的
下面有更简单的方式就是将obj强转成void**,也就是二级指针(其他类型的二级指针也是可以的,主要用的就是二级指针转换成一级指针的空间大小是4/8个字节),然后我们对他解引用,*(void**)obj = nullptr

上面是解决第一次内存块回收的问题,下面是解决多次回收的问题

多个内存块回收我们选择用头插的方式串起来,因为尾插效率太低

首先还是要让新的内存块保存_freeList指向的地址,然后让_freeList指向新的内存块

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

我们发现上面代码中

*(void**)obj = _freeList;_freeList = obj;

这段代码是适用于所有情况的
一开始_freeList=nullptr

让obj前4/8个字节保存_freeList

然后让_freeList指向obj

即使有新回收的也是适用的

代码

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

设计的总代码

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);//128kbif (_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(obj)T;return obj;}void Delete(T* obj){obj->~T();*(void**)obj = _freeList;_freeList = obj;}
private:char* _memory = nullptr;//指向大块内存的指针void* _freeList = 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;
}

Objectpool.h文件代码

#include<iostream>
#include<vector>
#include<time.h>
using std::cout;
using std::endl;
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);//128kbif (_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(obj)T;return obj;}void Delete(T* obj){obj->~T();*(void**)obj = _freeList;_freeList = obj;}
private:char* _memory = nullptr;//指向大块内存的指针void* _freeList = 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;
}

test.cpp文件代码

#include"Objectpool.h"
int main()
{TestObjectPool();return 0;  
}

拓展windows和Linux下如何直接向堆申请页为单位的大块内存：

VirtualAlloc
Linux进程分配内存的两种方式–brk() 和mmap()