高并發內存池實戰指南

項目源碼：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 Classvoid** 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;
}