C++ 高并发内存池实战：ThreadCache 设计与实现

ThreadCache 结构

容量设计上，最大支持 256KB，哈希桶总数为 208 个。

class ThreadCache {
public:
    void* Allocate(size_t size);
    void Deallocate(void* ptr, size_t size);
    void* FetchFromCentralCache(size_t blocksize, size_t index);

private:
    FreeList _freelists[FREELIST_NUMS];
};

内存对齐与索引计算

为了控制内碎片在 10% 左右，不同范围采用不同的对齐策略：

• [1, 128]: 8 字节对齐
• [129, 1024]: 16 字节对齐
• [1025, 8KB]: 128 字节对齐
• [8KB+1, 64KB]: 1KB 字节对齐
• [64KB+1, 256KB]: 8KB 字节对齐

真实大小计算

申请内存时，实际分配的块大小会向上取整到对齐数。为避免除法运算的低效，使用位操作优化。

static inline size_t _Real_Size(size_t bytes, size_t alignNum) {
    return ((bytes + alignNum - 1) & ~(alignNum - 1));
}

原理是 (bytes + alignNum - 1) 完成进位，& ~(alignNum - 1) 清除低位不足对齐的部分。

索引映射

根据申请大小找到对应的 FreeList 下标。同样利用位运算优化除法逻辑。

static inline size_t _Index(size_t bytes, size_t alignnum) {
    size_t _2_top = static_cast<size_t>(std::log2(alignnum));
    return ((bytes + (1 << _2_top) - 1) >> _2_top) - 1;
}

分配与释放接口

void* ThreadCache::Allocate(size_t size) {
    assert(size <= MAX_BYTES);
    size_t index = Calculate::Index(size);
    if (!_freelists[index].empty()) {
        return _freelists[index].Pop();
    } else {
        size_t block_size = Calculate::Real_Size(size);
        return FetchFromCentralCache(block_size, index);
    }
}

void ThreadCache::Deallocate(void* ptr, size_t size) {
    assert(ptr);
    assert(size);
    size_t index = Calculate::Index(size);
    _freelists[index].Push(ptr);
}

多线程私有缓存验证

在高并发场景下，每个线程需独立拥有 ThreadCache 实例，互不干扰且无需加锁。利用线程局部存储（TLS）实现。

// Windows 平台专用修饰符
static _declspec(thread) ThreadCache* TLSThreadCache = nullptr;

_declspec(thread) 确保变量存储在线程局部存储区，每个线程访问的是自己的副本。为防止多文件链接时的重定义错误，需声明为 static。

测试时创建两个线程分别申请内存，观察 TLSThreadCache 指针是否一致。调试结果显示，不同线程获取到的 ThreadCache 对象地址不同，验证了线程隔离的有效性。

void* ConcurrentAlloc(size_t size) {
    if (TLSThreadCache == nullptr)
        TLSThreadCache = new ThreadCache;
    cout << std::this_thread::get_id() << ":" << TLSThreadCache << endl;
    return TLSThreadCache->Allocate(size);
}

小结

本文完成了高并发内存池中 ThreadCache 模块的基础设计与实现。通过哈希桶结合自由链表，配合线程本地存储机制，实现了高效的无锁内存分配。后续将继续补充 CentralCache 与 PageCache 的交互逻辑，完善整个内存池体系。