当前位置：首页 > news >正文

网站正在建设中色关键词热度分析

news 2025/6/29 14:41:32

网站正在建设中色,关键词热度分析,建一个团购网站,离退休部门网站建设情况目录一，项目介绍二，什么是内存池 1，池化技术 2，内存池 3，内存池主要解决的问题 4，malloc 三，实现一个定长内存池定长内存池的设计大致结构核心功能实现申请一块大小为T的内存释…

一，项目介绍

二，什么是内存池

1，池化技术

2，内存池

3，内存池主要解决的问题

4，malloc

三，实现一个定长内存池

定长内存池的设计

大致结构

核心功能实现

申请一块大小为T的内存

释放一块大小为T的内存

完整的申请内存过程

测试代码

一，项目介绍

这个项目是实现一个高并发的内存池。它的原型是google的一个开源醒目tcmalloc，tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的线程内存管理，用于替代系统的相关内存分配函数(malloc,free)。

这个项目是对tcmalloc的一个简化版，是对tcmalloc的学习，实现一个我们自己的高并发内存池。

在该项目中涉及到的C++知识包括数据结构（链表，哈希桶），操作系统内存管理，单例模式，多线程以及互斥锁等等。

二，什么是内存池

1，池化技术

所谓池化技术，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次向操作系统申请资源时，都有较大的开销。如果我们提前申请好一块大的空间，再次申请时，直接使用就会变得非常快捷，大大提高程序运行效率。

在计算机中，有很多使用"池"这种技术的地方。除了内存池，还有连接池，线程池，对象池等等。以线程池为例，它的主要思想是：先启动若干线程，让他们进入休眠状态，当接收到客户端发来的任务请求时，唤醒其中的某个线程，让它来处理客户端的任务请求，当处理完这个请求，不是终止掉该线程，而是让该线程继续进入休眠状态。

2，内存池

内存池是指程序预先从操作系统申请一大块的内存。此后，当程序需要再次申请内存时，不是直接向操作系统申请，而是直接从内存池中获取；同理，当程序释放内存的时候，不是直接还给操作系统，而是还给内存池。当程序退出（或特定时间）时，内存池才将之前申请的内存真正释放，还给操作系统。

3，内存池主要解决的问题

内存池的设计就是为了解决频繁向操作系统申请资源的问题，从而提高程序运行的效率。

我们将内存池看作是系统的内存分配器，就还面临一个问题：内存碎片问题。内存碎片又分为内碎片和外碎片。

所谓外碎片问题，就是我们的程序先后申请了一大块内存之后，在释放内存的时候，有的释放了，有的还在使用，导致归还的内存不连续，如果下次再次申请内存的时候，可能会由于内存地址不连续的问题，导致申请内存失败。如下图：

对于内碎片，在后面的项目中会遇到，到时再讲解。

4，malloc

C/C++中，我们要动态申请内存都是通过malloc的，但是实际上，我们不是直接取堆上要内存的。

因为malloc本身就是一个内存池。malloc相当于向操作系统“批发”要了一大块的内存空间，然后“零售”给程序使用。当全部“售完”或者有大量的内存需求时，再根据实际需要向操作系统“进货”。

但是malloc在多线程环境下，内存申请效率不可观，这也是我们所实现的高并发内存池和malloc的重要区别。

如下图所示：

三，实现一个定长内存池

所谓定长内存池，顾名思义，它就是用来解决固定内存大小的申请。而我们的高并发内存池实现的是任意大小的内存申请。

为什么要实现一个定长内存池？

首先，定长内存池相对于高并发内存池来说，实现起来简单。同时定长内存池这里的实现设计思想，在后面的项目中也会使用到。

定长内存池的设计

有了对内存池的理解之后，这里的实现就没有什么太大的问题。

定长内存池，解决固定大小的内存申请，假设大小为n。

申请空间时

我们首先需要一个变量来记录这一大块内存的起始地址。我们可以定义一个char* memory的类型来记录这一大块内存的起始地址。使用char*来表示的好处是，char是一个字节大小，当申请n个字节的内存大小时，我们只需让memory向后走n个字节大小即可。不能使用void*，因为void*不能解引用，不能++。

释放空间时

由于在申请资源时，有的对象释放空间，有的还正在使用。所以这就有可能导致还回来的内存不一定是连续的。例如：本来连续的内存空间是1,2,3,4,5，还回来的时候可能是3,1,5。

所以我们不能再将这些内存资源让memory管理起来。

对于这些还回来的空间，我们可以将这些空间以链表的形式组织起来。按照以往的思路，我们会定义一个结构体，结构体中包含还回来的空间，以及一个next指针指向下一个还回来的结构体。
其实不需要我们自己定义一个结构体对象。对于这些还回来的内存，我们可以让它前4个字节（或者8个字节）存储下一个还回来的内存的地址。32位环境下是前4个字节，64位下就是前8个字节。具体看下图：

这样，我们就可以将还回来的内存以链表的组织起来，我们定义一个自由链表

void* freelist，来指向第一个还回来的内存的地址。

大致结构

//定长内存池
//定长大小就是T的类型大小
template <class T>
class FixedMemoryPool
{
public://...
private:char* _memory = nullptr;//大块内存的起始地址void* _freelist = nullptr;//自由链表，管理还回来的内存size_t _remainSize = 0;//记录当前内存池剩余的内存大小
};

核心功能实现

申请一块大小为T的内存

申请内存时，刚开始时整个内存池的大小是空的，此时我们需要向操作系统申请。

并且在分配内存过程中，如果剩余内存的大小，小于1个T类型的大小时，也需要向操作系统再次申请。这两种情况可以放在一起解决。

T* New()
{T* obj = nullptr;//申请的T对象//当剩余的空间大小不够一个对象的大小时，重新向操作系统申请一大块内存if (_remainSize <sizeof(T)){_remainSize = 128 * 1024;//申请128KB_memory = (char*)malloc(_remainSize);if (_memory == nullptr)//申请内存失败{throw::bad_alloc();}}obj = (T*)_memory;_memory += sizeof(T);_remainSize -= sizeof(T);return obj;
}

释放一块大小为T的内存

现在考虑两个问题：

如何将还回来的内存块以链表的形式组织在一起？？

对于还回来的两个对象obj1和obj2，我们现在要构成链表：obj1->obj2。我们可以先将obj1转换成int*类型，然后再解引用，就可以访问到obj1的前4个字节了。
即*(int*)obj1=obj2。这样就实现了让obj1的前4个字节存储上obj2的地址，这样就构建成了一条链表。

如何解决不同平台的问题，如果是32位机器，指针是4个字节大小。但如果是64位机器，指针式8个字节大小，上面的代码就跑不动了？？？

其实只需要改动一点即可了：*(int**)obj1=obj2；这里不一定是int**，也可以换成char**，long long**，void**，只要是二级指针就可以。
我们之前是将obj1强转成int类型，解引用后就可以访问4个字节的大小。此时我们将ob1强转成int**类型的，那么解引用后访问的内存大小就是int*大小的，而int*是一个指针，它在32位机器下是4字节，在64位环境下是8字节，所以解引用后就可以访问到4个字节（或8个字节），这样就可以解决不同环境的问题了。

然后实现释放内存的逻辑，使用自由链表将对应的内存块以链表的形式组织在一起。

将还回来的内存空间以链表的形式组织起来，让_freelist指向该链表的头节点。然后，每当释放一块内存时，将该内存块头插到链表中。

当有一块内存还回来时：

当自由链表为空时，我们只需让_freelist指向该内存，并让该内存块的前4个字节（或8个字节）填充上nullptr即可。此时_freelist指向该内存块，下一个内存块的地址为空。
当自由链表不为空时，我们先将该内存块的前4个字节（或8个字节）填充上_freelist的next地址，然后再让_freelist的next填充上当前内存块的地址即可
其实这两种情况下的头插时一样的，代码实现时一样的。

	void Delete(T* obj){//使用自由链表管理起来obj->~T();//头插*(void**)obj = _freelist;_freelist = obj;}

完整的申请内存过程

有了对上面释放内存块的理解，其实就是通过自由链表来维护这些还回来的内存块。

那么对于申请内存模块，还需要补充一点。就是在申请内存时，如果自由链表不为空，优先从自由链表中获取，这是一个头删的过程。让自由链表_freelist向后移动，指向下一个内存块。

还需要处理一个问题，就是如果我们申请的内存块大小不够4个字节（或8个字节）时，在管理还回来的内存时，内存块的大小不足4个字节（或8个字节），那么就无法存放地址。所以，为了解决这个问题，我们在申请内存时，如果所申请的内存大小不足4个字节（或者8个字节），就给它4个字节（或8个字节），因为至少是需要4个字节（或8个字节）的。

	T* New(){T* obj = nullptr;//申请的T对象//优先使用还回来的对象if (_freelist){//自由链表头删过程void* next = *(void**)_freelist;//保存下一个内存块的地址_obj = (T*)_freelist;_freelist = next;//指向下一个节点，完成头删}else{//当剩余的空间大小不够一个对象的大小时，重新向操作系统申请一大块内存if (_remainSize < sizeof(T)){_remainSize = 128 * 1024;//申请128KB_memory = (char*)malloc(_remainSize);if (_memory == nullptr)//申请内存失败{throw::bad_alloc();}}obj = (T*)_memory;//不足4个字节或8个字节时，就给4个字节或者8个字节大小size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);_memory += objSize)_remainSize -= objSize;}//使用定位new初始化new(obj)T;return obj;}

测试代码

这里以二叉树节点为例，比较标准库中的new和我们实现的内存池的性能

struct TreeNode
{int _val;TreeNode* _left;TreeNode* _right;TreeNode():_val(0), _left(nullptr), _right(nullptr){}
};void TestFiedMemoryPool()
{// 申请释放的轮次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);FixedMemoryPool<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;
}