高并发内存池实战指南

小文要打代码

发布于 2025-07-10 11:00:40

2340

文章被收录于专栏：C++学习历程C++学习历程

项目源码：https://gitee.com/kkkred/thread-caching-malloc

一、脱离new：高并发内存池如何替代传统动态分配

1.1 new的痛点：碎片、延迟与锁竞争

1.2 高并发内存池的替代方案：分层预分配+无锁管理

二、大内存（>256KB）处理：高并发内存池的扩展设计

2.1 策略1：多尺寸内存池组合

2.2 策略2：结合PageCache管理大页

三、释放优化：不传对象大小的实现原理

3.1 实现原理：格子对齐与元数据映射

3.2 优势：减少参数传递与校验开销

四、多线程对比测试：高并发内存池 vs malloc

4.1 测试环境

4.2 测试场景1：单线程高频分配释放（100万次）

4.3 测试场景2：多线程并发分配释放（8线程×100万次）

4.4 测试场景3：大内存（1MB）申请释放（1000次）

五、总结与最佳实践

5.1 高并发内存池的适用场景

5.2 最佳实践

一、脱离`new`：高并发内存池如何替代传统动态分配

1.1 `new`的痛点：碎片、延迟与锁竞争

new的本质是调用malloc分配内存，其核心问题在高并发场景下被放大：

内存碎片：频繁分配释放导致空闲内存被切割为大量不连续的小块，可用空间总和足够但无法满足单次申请（尤其在分配/释放模式不规律时）；
分配延迟波动：malloc需遍历空闲内存块链表（时间复杂度O(n)），小对象分配延迟从微秒级到毫秒级波动，无法满足高并发的确定性要求；
多线程锁竞争：全局锁（如ptmalloc的互斥锁）导致多线程分配时性能骤降（8线程场景下性能可能下降50%以上）。

1.2 高并发内存池的替代方案：分层预分配+无锁管理

高并发内存池通过以下设计彻底替代new：

预分配连续内存块：一次性申请大块内存（如1MB~1GB），切割为固定或动态大小的「逻辑格子」；
O(1)分配/释放：分配时直接取空闲格子链表头部（无锁），释放时插回链表头部（无需遍历）；
线程本地存储（TLS）：每个线程独立拥有内存池实例，避免全局锁竞争；
全局协调层：跨线程的大对象分配通过中央缓存（CentralCache）协调，减少系统调用。

代码示例：高并发内存池替代new

// 高并发内存池结构体（简化版）
typedef struct {
    void*   base_addr;          // 预分配的内存块起始地址
    size_t  total_size;         // 总内存大小
    size_t  used_size;          // 已使用内存大小
    SpinLock global_lock;       // 全局锁（保护大对象分配）
    ThreadLocalCache* tls_cache;// 线程本地缓存（TLS）
} HighConcurrencyPool;

// 初始化高并发内存池（替代new的全局分配）
HighConcurrencyPool* hcp_init(size_t total_size) {
    // 1. 预分配连续内存块（对齐到页大小）
    void* base_addr = mmap(NULL, total_size, PROT_READ | PROT_WRITE, 
                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (base_addr == MAP_FAILED) return NULL;

    // 2. 初始化线程本地缓存（TLS）
    ThreadLocalCache* tls_cache = (ThreadLocalCache*)malloc(sizeof(ThreadLocalCache));
    tls_cache->free_list = (void**)calloc(MAX_SIZE_CLASS, sizeof(void*));  // 按Size Class分类的空闲链表

    // 3. 初始化全局内存池
    HighConcurrencyPool* pool = (HighConcurrencyPool*)malloc(sizeof(HighConcurrencyPool));
    pool->base_addr = base_addr;
    pool->total_size = total_size;
    pool->used_size = 0;
    pool->tls_cache = tls_cache;
    pthread_mutex_init(&pool->global_lock, NULL);

    return pool;
}

// 分配函数（替代new，无锁线程本地操作）
void* hcp_alloc(HighConcurrencyPool* pool, size_t size) {
    // 1. 从线程本地缓存分配（O(1)时间）
    ThreadLocalCache* tls = pool->tls_cache;
    size_t sc = align_to_size_class(size);  // 对齐到最近的Size Class
    void** bucket = &tls->free_list[sc];
    if (*bucket) {
        void* obj = *bucket;
        *bucket = *(void**)obj;  // 链表指针前移
        return obj;
    }

    // 2. 本地无空闲对象，向全局缓存申请（批量分配）
    pthread_mutex_lock(&pool->global_lock);
    void* chunk = allocate_from_global(pool, sc);  // 从全局池申请一批对象
    pthread_mutex_unlock(&pool->global_lock);

    if (chunk) {
        // 将新分配的对象插入本地缓存
        *bucket = chunk;
        *(void**)(chunk + sizeof(void*)) = tls->free_list[sc];  // 链表指针前移
        tls->free_list[sc] = chunk;
        return chunk;
    }

    return NULL;  // 全局池无内存，触发扩容或返回NULL
}

结论：高并发内存池通过预分配和线程本地存储，彻底替代了new的动态分配逻辑，避免了碎片和锁竞争问题。

二、大内存（>256KB）处理：高并发内存池的扩展设计

传统malloc分配大内存（如256KB~4MB）时，常因内存碎片导致分配失败或延迟极高。高并发内存池通过以下策略高效处理大内存：

2.1 策略1：多尺寸内存池组合

为不同大小的对象创建独立的定长内存池，覆盖从8B到4MB的全场景需求。例如：

8B~256B：使用128B格子的定长池（ThreadCache本地管理）；
256B~1KB：使用256B格子的定长池（ThreadCache本地管理）；
1KB~4MB：使用4KB格子的定长池（结合CentralCache全局协调）；
4MB：直接调用mmap申请匿名页（PageCache管理）。

实现逻辑：

// 多尺寸内存池管理器
typedef struct {
    HighConcurrencyPool* pools[LOG2(4 * 1024 * 1024)];  // 按2的幂次划分格子大小
    int num_pools;
} MultiSizePool;

// 根据对象大小选择对应的定长池
HighConcurrencyPool* multi_size_pool_select(MultiSizePool* manager, size_t size) {
    size_t aligned_size = align_to_power_of_two(size);
    for (int i = 0; i < manager->num_pools; i++) {
        if (aligned_size <= (1 << (i + 3))) {  // 8B~4MB（2^3~2^22）
            return manager->pools[i];
        }
    }
    // 超出范围，直接调用mmap申请大内存
    return NULL;
}

2.2 策略2：结合PageCache管理大页

对于超过4MB的大内存，高并发内存池可结合PageCache（管理页级内存）实现：

大内存申请：通过PageCache申请连续页（如4KB/页），切割为大内存块；
大内存释放：释放时归还给PageCache，由PageCache批量回收给操作系统。

代码示例（大内存申请）：

// 高并发内存池扩展：申请大内存（>4MB）
void* hcp_alloc_large(HighConcurrencyPool* pool, size_t size) {
    // 1. 计算需要的页数（向上取整到页大小）
    size_t page_size = sysconf(_SC_PAGESIZE);  // 获取系统页大小（通常4KB）
    size_t required_pages = (size + page_size - 1) / page_size;

    // 2. 向PageCache申请连续页（调用PageCache的get_span接口）
    Span* span = page_cache_get_span(pool->page_cache, required_pages);
    if (!span) return NULL;

    // 3. 将页转换为虚拟地址返回
    return page_to_addr(span->start_page);
}

结论：通过多尺寸池组合或结合PageCache，高并发内存池可高效处理大内存申请，避免malloc的碎片问题。

三、释放优化：不传对象大小的实现原理

传统释放函数（如free或自定义pool_free）需要传递对象大小，以确定释放的内存范围。而高并发内存池通过固定格子对齐和空闲链表管理，可实现「无对象大小释放」，进一步降低开销。

3.1 实现原理：格子对齐与元数据映射

高并发内存池的每个格子大小固定（如128B、256B），释放时只需知道对象起始地址，即可通过地址对齐确定其所属的格子。例如：

格子大小=256B → 对象起始地址必为256B的整数倍；
释放时，通过(addr - base_addr) / chunk_size计算格子索引，直接插入对应空闲链表。

代码示例（无对象大小释放）：

// 释放函数（无需传递对象大小）
void hcp_free(HighConcurrencyPool* pool, void* ptr) {
    // 1. 校验指针是否在内存池范围内
    char* base = (char*)pool->base_addr;
    char* end = base + pool->total_size;
    char* ptr_char = (char*)ptr;
    if (ptr_char < base || ptr_char >= end) return;  // 非法指针

    // 2. 计算格子索引（通过地址对齐）
    size_t offset = ptr_char - base;
    size_t chunk_size = get_chunk_size_by_offset(offset);  // 根据偏移量获取格子大小
    size_t chunk_idx = offset / chunk_size;

    // 3. 插入线程本地的空闲链表头部（O(1)时间）
    ThreadLocalCache* tls = pool->tls_cache;
    void** bucket = &tls->free_list[chunk_idx];
    *(void**)ptr = *bucket;  // 链表指针前移
    *bucket = ptr;
}