C++项目-- 高并发内存池（一）
文章目录
一、项目介绍
1.项目来源
当前项目是实现一个高并发的内存池，他的原型是google的一个开源项目tcmalloc，tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替代系统的内存分配相关的函数（malloc、free），Go语言直接用它做了自己内存分配器。
本项目是把tcmalloc最核心的框架简化后拿出来，模拟实现出一个自己的高并发内存池，目的就是学习tcamlloc的精华。
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是否为空了，都是一样的操作 - 需要显式调用析构函数完成对象的清理
- 将还回来的对象加入到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 _WIN32
void* ptr = VirtualAlloc(0, kpage << 13, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
#else
#endif // _WIN32
if (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;
};
三、要点
- 当剩余空间不足一个对象时，就需要重新开辟空间；
- 开辟空间时，首先考虑将freeList中已经归还的空间再次分配出去；
- freeList使用头插和头删，降低时间复杂度；
- 使用
*((void**)obj)的方式，来自动适配不同位的系统下指针的大小
1292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
