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

注意构造函数的处理。为了避免初始化时的重复开销，这里采用默认参数或隐式初始化，方便调试观察。

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, 8K]：128 字节对齐，对应 freelist[72, 128)
• [8K+1, 64K]：1024 字节对齐，对应 freelist[128, 184)
• [64K+1, 256K]：8K 字节对齐，对应 freelist[184, 208)

关键算法优化

1. 计算真实内存块大小

直接申请的大小可能不满足对齐要求，需要向上取整。简单的除法效率较低，可采用位运算优化。

// 判断要开辟的真实字节数
static size_t Real_Size(size_t size) {
    if (size <= 128) return _Real_Size(size, 8);
    else if (size <= 1024) return _Real_Size(size, 16);
    else if (size <= 8 * 1024) return _Real_Size(size, 128);
    else if (size <= 64 * 1024) return _Real_Size(size, 1024);
    else if (size <= 256 * 1024) return _Real_Size(size, 8 * 1024);
    else { assert(false); return -1; }
}

// 位运算实现向上对齐
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 size_t Index(size_t size) {
    int groups[4] = {16, 56, 56, 56};
    if (size <= 128) return _Index(size, 8);
    else if (size <= 1024) return groups[0] + _Index(size - 128, 16);
    else if (size <= 8 * 1024) return groups[0] + groups[1] + _Index(size - 1024, 128);
    else if (size <= 64 * 1024) return groups[0] + groups[1] + groups[2] + _Index(size - 64 * 1024, 1024);
    else if (size <= 256 * 1024) return groups[0] + groups[1] + groups[2] + groups[3] + _Index(size - 256 * 1024, 8 * 1024);
    else { assert(false); return -1; }
}

// 优化后的索引计算
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;
}

Allocate 与 Deallocate 实现

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 设计

在高并发场景下，每个线程应拥有独立的 ThreadCache 实例，避免锁竞争。利用线程局部存储（TLS）特性可实现这一点。

// Windows 平台专用关键字
_declspec(thread) ThreadCache* TLSThreadCache = nullptr;

解释：_declspec(thread) 修饰的对象存储在线程局部存储区。每个线程访问该变量时，实际访问的是其私有的副本，从而实现了无锁化。

为避免多个源文件链接时的重定义错误，需将其声明为 static：

static _declspec(thread) ThreadCache* TLSThreadCache = nullptr;

测试验证

编写多线程测试程序，验证每个线程是否获取到独立的 ThreadCache 实例。

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;
}

void* ConcurrentAlloc(size_t size) {
    if (TLSThreadCache == nullptr)
        TLSThreadCache = new ThreadCache;
    
    // 打印线程 ID 和 Cache 地址进行验证
    cout << std::this_thread::get_id() << ":" << TLSThreadCache << endl;
    return TLSThreadCache->Allocate(size);
}

测试结果显示，不同线程获取到的 TLSThreadCache 指针地址不同，且同一线程多次调用保持一致。这证明了线程私有缓存机制生效，互不干扰。

小结

本文完成了高并发内存池中 ThreadCache 模块的基础设计与实现。通过 FreeList 管理小对象，利用 TLS 实现线程隔离，有效减少了锁竞争。后续将在此基础上补充 CentralCache 与 PageCache 的实现，进一步完善内存池架构。