好的，各位好！今天咱们来聊聊C++里一个挺有意思的话题：内存池。特别是针对那些“小不点儿”对象，内存池能帮我们解决不少麻烦。
引子：为啥要搞内存池？
想象一下，你开了一家包子铺。客人来了，要一个包子，你就现揉面、现做馅儿、现蒸，客人吃完走了，你又得把家伙什儿收拾干净。如果客人接二连三地来，你是不是得忙得脚不沾地？
C++里的new和delete就像这个现做包子的过程。每次new，都要向操作系统申请内存，delete又要归还。这个过程很费劲，特别是当你要频繁地创建和销毁很多小对象的时候。操作系统就像一个大管家，你每次找它要点儿东西，它都要登记、分配、回收，累都累死了，效率自然就下来了。
那么，内存池就像什么呢？就像你提前揉好了一堆面，调好了一堆馅儿，客人来了直接拿来蒸就行。客人吃完，你也不用收拾，直接留给下一个客人用。这样是不是快多了？
什么是内存池？
内存池，简单来说，就是预先分配一大块连续的内存，然后自己管理这块内存，按需分配给程序使用。当对象不再需要时，并不立即释放给操作系统，而是放回内存池中，供下次分配使用。
内存池的优点：
- 速度快： 避免了频繁的系统调用，分配和释放内存的速度大大提升。
- 减少内存碎片： 连续分配内存，减少了内存碎片产生的可能性，提高了内存利用率。
- 可控性强： 可以自定义内存分配策略，例如，可以限制最大分配数量，防止内存泄漏。
内存池的缺点：
- 实现复杂： 需要自己管理内存，实现起来比
new和delete复杂。 - 额外开销： 内存池本身需要占用一定的内存空间。
- 灵活性差： 内存池的大小在创建时就固定了，如果需要的内存超过了内存池的大小，就无法分配。
适用场景：
- 频繁创建和销毁小对象： 例如，游戏中的粒子、网络编程中的消息对象等。
- 对性能要求高的场景： 例如，实时系统、嵌入式系统等。
内存池的实现方式：
常见的内存池实现方式有两种：
- 固定大小块内存池： 每个块的大小都一样，适合分配大小相同的对象。
- 变长块内存池： 块的大小可以不同，适合分配大小不同的对象。
咱们今天主要讲固定大小块内存池，因为这种方式更简单、更高效。
固定大小块内存池的实现：
实现固定大小块内存池，我们需要考虑以下几个问题：
- 如何分配内存块？
- 如何记录哪些内存块是空闲的？
- 如何分配和释放内存块？
一种常见的实现方式是使用链表来管理空闲的内存块。每个内存块都有一个指向下一个空闲内存块的指针。
下面是一个简单的固定大小块内存池的实现代码：
#include <iostream>
#include <cassert>
template <typename T>
class FixedSizeBlockAllocator {
public:
FixedSizeBlockAllocator(size_t blockSize, size_t blocksCount)
: blockSize_(blockSize), blocksCount_(blocksCount), freeList_(nullptr) {
// 分配一大块连续的内存
memoryPool_ = new char[blockSize_ * blocksCount_];
assert(memoryPool_ != nullptr);
// 将内存块链接成链表
char* currentBlock = memoryPool_;
for (size_t i = 0; i < blocksCount_ - 1; ++i) {
*reinterpret_cast<char**>(currentBlock) = currentBlock + blockSize_;
currentBlock += blockSize_;
}
*reinterpret_cast<char**>(currentBlock) = nullptr; // 最后一个块的next指针设为nullptr
freeList_ = memoryPool_;
}
~FixedSizeBlockAllocator() {
delete[] memoryPool_;
memoryPool_ = nullptr;
freeList_ = nullptr;
}
T* allocate() {
if (freeList_ == nullptr) {
return nullptr; // 内存池已满
}
// 从链表中取出一个空闲块
char* block = freeList_;
freeList_ = *reinterpret_cast<char**>(freeList_);
return reinterpret_cast<T*>(block);
}
void deallocate(T* ptr) {
if (ptr == nullptr) {
return;
}
// 将内存块放回链表
char* block = reinterpret_cast<char*>(ptr);
*reinterpret_cast<char**>(block) = freeList_;
freeList_ = block;
}
private:
char* memoryPool_; // 内存池
char* freeList_; // 空闲块链表
size_t blockSize_; // 每个块的大小
size_t blocksCount_; // 块的数量
};
//测试代码
struct MyObject {
int x;
int y;
};
int main() {
// 创建一个块大小为sizeof(MyObject)，数量为10的内存池
FixedSizeBlockAllocator<MyObject> allocator(sizeof(MyObject), 10);
// 分配几个对象
MyObject* obj1 = allocator.allocate();
MyObject* obj2 = allocator.allocate();
if (obj1) {
obj1->x = 10;
obj1->y = 20;
std::cout << "obj1: x = " << obj1->x << ", y = " << obj1->y << std::endl;
}
if (obj2) {
obj2->x = 30;
obj2->y = 40;
std::cout << "obj2: x = " << obj2->x << ", y = " << obj2->y << std::endl;
}
// 释放对象
allocator.deallocate(obj1);
allocator.deallocate(obj2);
//再次分配
MyObject* obj3 = allocator.allocate();
if (obj3) {
obj3->x = 50;
obj3->y = 60;
std::cout << "obj3: x = " << obj3->x << ", y = " << obj3->y << std::endl;
allocator.deallocate(obj3);
}
return 0;
}代码解释：
FixedSizeBlockAllocator类： 实现了固定大小块内存池。memoryPool_： 指向预先分配的内存块。freeList_： 指向空闲块链表的头。blockSize_： 每个块的大小。blocksCount_： 块的数量。allocate()方法： 从空闲块链表中取出一个块，返回给用户。如果链表为空，则返回nullptr。deallocate()方法： 将用户释放的块放回空闲块链表。
代码重点：
reinterpret_cast： 这个强制类型转换很重要，用于将char*转换为char**，以便在内存块中存储指向下一个空闲块的指针。- 空闲链表管理：
freeList_指针始终指向下一个可用的内存块。分配时，freeList_更新为指向链表中的下一个节点。释放时，被释放的块被添加到freeList_的头部。
更高级的用法：placement new
C++ 里有一个叫做 "placement new" 的操作符，它允许你在已分配的内存上构造对象。这和内存池简直是天作之合。 使用 placement new，你可以在从内存池分配的原始内存上直接构造对象，避免了额外的内存拷贝。
#include <iostream>
#include <new> // 包含 placement new 需要的头文件
template <typename T>
class FixedSizeBlockAllocator {
public:
FixedSizeBlockAllocator(size_t blockSize, size_t blocksCount)
: blockSize_(blockSize), blocksCount_(blocksCount), freeList_(nullptr) {
memoryPool_ = new char[blockSize_ * blocksCount_];
assert(memoryPool_ != nullptr);
char* currentBlock = memoryPool_;
for (size_t i = 0; i < blocksCount_ - 1; ++i) {
*reinterpret_cast<char**>(currentBlock) = currentBlock + blockSize_;
currentBlock += blockSize_;
}
*reinterpret_cast<char**>(currentBlock) = nullptr;
freeList_ = memoryPool_;
}
~FixedSizeBlockAllocator() {
delete[] memoryPool_;
memoryPool_ = nullptr;
freeList_ = nullptr;
}
T* allocate() {
if (freeList_ == nullptr) {
return nullptr;
}
char* block = freeList_;
freeList_ = *reinterpret_cast<char**>(freeList_);
// 使用 placement new 在已分配的内存上构造对象
return new (block) T(); // 调用 T 的默认构造函数
}
void deallocate(T* ptr) {
if (ptr == nullptr) {
return;
}
// 调用析构函数
ptr->~T();
char* block = reinterpret_cast<char*>(ptr);
*reinterpret_cast<char**>(block) = freeList_;
freeList_ = block;
}
private:
char* memoryPool_;
char* freeList_;
size_t blockSize_;
size_t blocksCount_;
};
struct MyObject {
int x;
int y;
MyObject() : x(0), y(0) {
std::cout << "MyObject constructor called" << std::endl;
}
~MyObject() {
std::cout << "MyObject destructor called" << std::endl;
}
};
int main() {
FixedSizeBlockAllocator<MyObject> allocator(sizeof(MyObject), 3);
MyObject* obj1 = allocator.allocate();
if (obj1) {
obj1->x = 1;
obj1->y = 2;
std::cout << "obj1: x = " << obj1->x << ", y = " << obj1->y << std::endl;
allocator.deallocate(obj1);
}
MyObject* obj2 = allocator.allocate();
if (obj2) {
obj2->x = 3;
obj2->y = 4;
std::cout << "obj2: x = " << obj2->x << ", y = " << obj2->y << std::endl;
allocator.deallocate(obj2);
}
return 0;
}代码解释：
new (block) T()： 这行代码就是 placement new 的用法。它在block指向的内存上构造一个T类型的对象，并返回指向该对象的指针。ptr->~T()： 在释放内存之前，必须显式调用对象的析构函数，以确保对象正确清理资源。
一些优化建议：
- 对齐： 为了提高内存访问效率，可以对内存块进行对齐。例如，可以将每个块的大小对齐到 4 字节或 8 字节。
- 多线程： 如果在多线程环境中使用内存池，需要考虑线程安全问题。可以使用互斥锁来保护内存池的访问。
- 预分配： 可以在程序启动时预先分配内存池，避免在使用时频繁分配内存。
内存池的变体：
除了上面介绍的固定大小块内存池，还有一些其他的内存池变体，例如：
- 变长块内存池： 可以分配大小不同的内存块，实现更复杂，但灵活性更高。
- 对象池： 专门用于管理特定类型的对象，可以提供更高级的功能，例如，对象复用。
总结：
内存池是一种有效的内存管理技术，可以提高程序的性能和内存利用率。虽然实现起来比new和delete复杂，但在某些场景下，使用内存池可以带来显著的优势。希望今天的讲解能帮助大家更好地理解和使用内存池。
最后的提示：
- 谨慎使用： 内存池并非万能的。在决定使用内存池之前，需要仔细评估其优缺点，并根据实际情况选择合适的内存管理方式。
- 测试： 使用内存池后，需要进行充分的测试，确保其稳定性和正确性。
- 调试： 内存池相关的错误往往比较难调试。需要使用合适的调试工具和技巧，才能快速定位问题。
好了，今天的分享就到这里。希望大家有所收获！ 谢谢大家！