C++项目-- 高并发内存池（一）

文章目录

C++项目-- 高并发内存池（一）
一、项目介绍
- 1.项目来源
- 2.内存池介绍
- - 1.池化技术
  - 2.内存池
  - 3.内存池主要解决的问题
  - 4.malloc
二、定长内存池
- 1.定长内存池的设计
- 2.代码实现
- 3.性能测试
- 4.直接在堆上申请空间
三、要点

一、项目介绍

1.项目来源

当前项目是实现一个高并发的内存池，他的原型是google的一个开源项目tcmalloc，tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替代系统的内存分配相关的函数（malloc、free），Go语言直接用它做了自己内存分配器。
本项目是把tcmalloc最核心的框架简化后拿出来，模拟实现出一个自己的高并发内存池，目的就是学习tcamlloc的精华。

tcmalloc源码地址

2.内存池介绍

1.池化技术

所谓“池化技术”，就是程序先向系统申请过量的资源，然后自己管理，以备不时之需。之所以要申请过量的资源，是因为每次申请该资源都有较大的开销，不如提前申请好了，这样使用时就会变得非常快捷，大大提高程序运行效率。
在计算机中，有很多使用“池”这种技术的地方，除了内存池，还有连接池、线程池、对象池等。以服务器上的线程池为例，它的主要思想是：先启动若干数量的线程，让它们处于睡眠状态，当接收到客户端的请求时，唤醒池中某个睡眠的线程，让它来处理客户端的请求，当处理完这个请求，线程又进入睡眠状态。

2.内存池

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

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

内存池主要解决的当然是效率的问题，其次如果作为系统的内存分配器的角度，还需要解决一下内存碎片的问题。那么什么是内存碎片呢？
在这里插入图片描述
再需要补充说明的是内存碎片分为外碎片和内碎片，上面我们讲的是外碎片问题。

外部碎片是一些空闲的连续内存区域太小，这些内存空间不连续，以至于合计的内存足够，但是不能满足一些的内存分配申请需求。
内部碎片是由于一些对齐的需求，导致分配出去的空间中一些内存无法被利用。内碎片问题，我们后面项目就会看到，那会再进行更准确的理解。

4.malloc

C/C++中我们要动态申请内存都是通过malloc去申请内存，但是我们要知道，实际我们不是直接去堆获取内存的，而malloc就是一个内存池。malloc() 相当于向操作系统“批发”了一块较大的内存空间，然后“零售”给程序用。当全部“售完”或程序有大量的内存需求时，再根据实际需求向操作系统“进货”。
malloc的实现方式有很多种，一般不同编译器平台用的都是不同的。比如windows的vs系列用的微软自己写的一套，linux gcc用的glibc中的ptmalloc。

一文了解，Linux内存管理，malloc、free 实现
malloc()背后的实现原理——内存池
malloc的底层实现（ptmalloc）

二、定长内存池

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

1.定长内存池的设计

解决固定大小的内存申请和释放需求
特点：
- 性能达到极致
- 不考虑内存碎片问题
使用char*指针指向内存池的首地址，方便以字节长度管理内存；
增加freeList机制，用于管理归还的内存块，而不是直接归还到内存池

2.代码实现

可以用非类型模板参数构建定长内存池，传入的模板参数N就是内存池的大小
也可以使用类型模板参数，由于类型的大小是固定的，因此每次申请的内存大小也是固定的
为了配合后面的高并发内存池，选择这种方案
成员变量：
- _memory：指向未分配内存的指针，指向的是内存的地址，定义为void类型不好进行++操作，定义为char类型方便进行字节操作
- _freeList：自由链表用来管理归还回来的内存块，每个内存块都是一个节点，前一个内存块的前四个字节存储下一个内存块的地址
- _remainBytes：剩余内存空间的字节数
New函数：用来为对象申请内存空间
- 第一次使用，初始化申请内存空间，报错抛异常
- 分配对象空间，对象的指针指向_memory，_memory向后移动
- 剩余内存空间不足，需要重新申请空间（当剩余空间不足以开辟一个T对象的时候，就需要申请空间了）
- freeList里面的空间是归还的空间，也是可以用于空间申请的，因此在freeList不为空时，优先将其中的内存块重复利用，开辟出去的内存块使用链表的头删
- 由于内存块在delete的时候需要存储其他内存块的指针，因此一个内存块的大小不能小于当前系统指针的大小
- 如果T是自定义类型，使用New只开了空间，并没有初始化，可以对一块已经有的空间调用构造函数进行初始化，就是定位new
Delete函数：用于处理还回来的对象的内存空间
- 将还回来的对象加入到freelist中
- _freeList存储的是第一个内存块的地址，第一个内存块的头4个字节用于存储下一个内存块的地址（将obj强转成int*类型，再解引用，就可以完成对该内存块头四字节的访问）
- （重点）在32位系统下，地址是4字节，但是64位系统下地址是8字节，可以通过将obj指针强转成void**类型，再解引用，这样obj访问的就是void*的大小，而void*是指针，其大小正取决于操作系统的位数，这样在32位系统下，void*为4字节，64位系统下，void*为8字节（重点）
- 第二个内存块插入链表使用头插法，减少时间复杂度
  
  这样就不用区分freeList是否为空了，都是一样的操作
- 需要显式调用析构函数完成对象的清理

ObjectPool.h

#pragma once
#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::vector;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);if (_memory == nullptr) {throw std::bad_alloc();}}//为新对象分配内存空间obj = (T*)_memory;//一个内存块的大小不能小于当前系统指针的大小，因为freeList需要存指针int objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);_memory += objSize;_remainBytes -= objSize;}//自定义类型只开辟了空间，并没有初始化，定位new，显式调用类的构造函数new(obj)T;return obj;}void Delete(T* obj) {//显式调用类的析构函数obj->~T();//头插*((void**)obj) = _freeList;_freeList = obj;}private:char* _memory = nullptr;void* _freeList = nullptr;int _remainBytes = 0;
};

3.性能测试

分别使用new和定长内存池去申请和释放N次资源，一共3轮，分别记录时间
在release版本下测试

#include "ObjectPool.h"struct TreeNode
{int _val;TreeNode* _left;TreeNode* _right;TreeNode():_val(0), _left(nullptr), _right(nullptr){}
};
void TestObjectPool()
{// 申请释放的轮次const size_t Rounds = 3;// 每轮申请释放多少次const size_t N = 100000;size_t begin1 = clock();std::vector<TreeNode*> v1;v1.reserve(N);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();ObjectPool<TreeNode> TNPool;size_t begin2 = clock();std::vector<TreeNode*> v2;v2.reserve(N);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;
}int main() {TestObjectPool();return 0;
}

在这里插入图片描述
可以看出定长内存池的速度优势很明显；

4.直接在堆上申请空间

我们可以使用系统接口，绕过malloc，直接在堆上申请空间；

windows使用VirtualAlloc函数来直接在堆上获取内存空间
linux下使用brk mmap等

#pragma once
#include <iostream>
#include <vector>
using std::cout;
using std::endl;
using std::vector;#ifdef _WIN32#include<windows.h>
#else#endif//直接去堆上申请空间
inline static void* SystemAlloc(size_t kpage) {
#ifdef _WIN32void* ptr = VirtualAlloc(0, kpage << 13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#else#endif // _WIN32if (ptr == nullptr) {throw std::bad_alloc();}return ptr;
}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) {throw std::bad_alloc();}}//为新对象分配内存空间obj = (T*)_memory;//一个内存块的大小不能小于当前系统指针的大小，因为freeList需要存指针int objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);_memory += objSize;_remainBytes -= objSize;}//自定义类型只开辟了空间，并没有初始化，定位new，显式调用类的构造函数new(obj)T;return obj;}void Delete(T* obj) {//显式调用类的析构函数obj->~T();//头插*((void**)obj) = _freeList;_freeList = obj;}private:char* _memory = nullptr;void* _freeList = nullptr;int _remainBytes = 0;
};