C++高效内存池实现减少动态分配开销的解决方案

// 使用TCMalloc分配内存（需链接tcmalloc库）
#include <gperftools/malloc.h>

void* ptr = malloc(1024);  // 实际调用TCMalloc
// 使用完毕后释放
free(ptr);

// Jemalloc的典型用法（需安装jemalloc开发包）
#include <jemalloc/jemalloc.h>

void* ptr = je_malloc(1024);  // 显式使用jemalloc接口
// 分配带标签的内存（便于性能分析）
void* tagged_ptr = je_mallocx(1024, JE_MALLOCX_TAG(0x123));
// 释放内存
je_free(ptr);

template <size_t ChunkSize, size_t ChunkCount>
class FixedSizeMemoryPool {
private:
    char* memoryBlock;        // 预分配的内存块
    bool* chunkStatus;        // 块状态标记
    std::atomic<size_t> freeChunks;  // 空闲块计数
    
public:
    FixedSizeMemoryPool() {
        // 一次性分配大块内存
        memoryBlock = new char[ChunkSize * ChunkCount];
        chunkStatus = new bool[ChunkCount]();
        freeChunks = ChunkCount;
        
        // 初始化内存块
        for (size_t i = 0; i < ChunkCount; ++i) {
            chunkStatus[i] = true;  // 标记为可用
        }
    }
    
    ~FixedSizeMemoryPool() {
        delete[] memoryBlock;
        delete[] chunkStatus;
    }
    
    // 分配内存块
    void* allocate() {
        for (size_t i = 0; i < ChunkCount; ++i) {
            if (std::atomic_exchange(&chunkStatus[i], false)) {
                freeChunks--;
                return memoryBlock + i * ChunkSize;
            }
        }
        return nullptr;  // 分配失败
    }
    
    // 释放内存块
    bool deallocate(void* ptr) {
        if (!ptr) return false;
        
        // 计算块索引
        size_t index = (reinterpret_cast<char*>(ptr) - memoryBlock) / ChunkSize;
        if (index >= ChunkCount) return false;
        
        // 标记为可用
        if (std::atomic_exchange(&chunkStatus[index], true)) {
            freeChunks++;
            return true;
        }
        return false;
    }
    
    size_t getFreeChunks() const {
        return freeChunks;
    }
};