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

3. ThreadCache 结构设计

容量配置如下：

static const int MAX_BYTES = 256 * 1024;   // 线程缓存最大 256KB
static const int FREELIST_NUMS = 208;      // 哈希桶个数

内部维护一个 FreeList 数组：

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];       // 哈希桶数组
};

大小对齐策略

为了减少浪费，不同区间采用不同的对齐方式：

• [1, 128]：8 字节对齐，对应 freelist[0, 16)
• [129, 1024]：16 字节对齐，对应 freelist[16, 72)
• [1025, 8KB]：128 字节对齐，对应 freelist[72, 128)
• [8KB+1, 64KB]：1KB 对齐，对应 freelist[128, 184)
• [64KB+1, 256KB]：8KB 对齐，对应 freelist[184, 208)

关键算法优化

1. 计算真实内存块大小

初始方案使用除法取整，但在高频调用下效率较低。改进为位运算：

// 向上取整到 alignNum 的倍数
static inline size_t _Real_Size(size_t bytes, size_t alignNum) {
    return ((bytes + alignNum - 1) & ~(alignNum - 1));
}

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

2. 计算 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);
}

4. 线程局部存储（TLS）实现

为确保多线程环境下各线程拥有独立的 ThreadCache，需使用线程局部存储。

Windows 平台可使用 _declspec(thread) 修饰全局变量：

static _declspec(thread) ThreadCache* TLSThreadCache = nullptr;

加上 static 是为了避免多文件编译时的重定义错误。该变量在每个线程中拥有独立副本，互不干扰。

在入口函数中初始化：

void* ConcurrentAlloc(size_t size) {
    if (TLSThreadCache == nullptr)
        TLSThreadCache = new ThreadCache;
    
    // 每个线程访问自己的 TLS 变量，实现无锁化
    return TLSThreadCache->Allocate(size);
}

三、多线程验证

通过创建多个线程分别调用 ConcurrentAlloc，验证 TLS 机制是否生效。观察各线程持有的 TLSThreadCache 指针地址是否一致且独立。

测试代码示例：

void alloc1() {
    for (int i = 0; i < 3; ++i) {
        void* ptr = ConcurrentAlloc(7);
    }
}

void alloc2() {
    for (int i = 0; i < 3; ++i) {
        void* ptr = ConcurrentAlloc(10);
    }
}

int main() {
    std::thread t1(alloc1);
    t1.join();
    std::thread t2(alloc2);
    t2.join();
    return 0;
}

调试时可并行监视 TLSThreadCache 指针。结果显示，同一线程多次调用返回的地址相同，不同线程返回的地址不同。这证明了每个线程都成功获取了独立的 ThreadCache 实例，实现了无锁分配。

四、总结

本文完成了 C++ 高并发内存池中 ThreadCache 模块的基础设计与实现。通过哈希桶与自由链表结构，结合线程局部存储技术，有效解决了小内存对象的快速分配与回收问题。后续将继续完善 CentralCache 与 PageCache 的实现，构建完整的内存池系统。