本文介绍高并发内存池设计中的两大核心优化：大页内存管理与定长内存池。针对大对象（>256KB），通过 PageCache 批量申请连续物理页并维护 span 链表，减少系统调用与碎片化。针对元数据对象（如 span、ThreadCache），采用定长 ObjectPool 预分配内存，利用定位 new 和显式析构彻底脱离 new/delete 开销。结合三级缓存架构，实现低延迟、高吞吐的内存管理方案。
在高并发内存池的设计中，"大页内存管理"和"元数据开销优化"是两个核心痛点：原生 malloc/free 在大内存分配时频繁触发系统调用，而 new/delete 管理内存池元对象（如 ThreadCache、span）会引入额外性能损耗。本文基于 TCMalloc 思想，拆解高并发内存池中大页内存的申请/释放逻辑，以及如何通过**定长内存池（ObjectPool）**彻底脱离 new/delete，实现元数据的零开销管理。
在高并发内存池的三级缓存架构（ThreadCache→CentralCache→PageCache）中，我们将内存分为"小对象（≤256KB）"和"大对象（>256KB）"：
因此，大对象直接走 PageCache 申请连续物理页（大页），跳过 ThreadCache 和 CentralCache，核心目标是：
我们定义"大对象"为超过 256KB 的内存（可根据场景调整），对应物理页数量为：
// Common.h 核心宏定义
#define MAX_BYTES (256 * 1024) // 小对象上限
#define PAGE_SIZE 8192 // 单页 8KB
#define PAGE_SHIFT 13 // 2^13=8192，用于页 ID 与地址转换
#define MAX_PAGE_BUCKETS 128 // 最大连续页数量（128*8KB=1024KB）
typedef size_t PAGE_ID; // 页 ID 类型
当申请内存 size > MAX_BYTES 时，判定为大对象，直接走 PageCache 申请连续页（大页），而非三级缓存。
大页申请的核心是"以页为单位分配连续物理页"，避免原生 malloc 的碎片化问题，核心代码如下：
// ConcurrentAlloc.h - 用户层大对象申请接口
void* ConcurrentAlloc(size_t size) {
if (size > MAX_BYTES) {
// 1. 内存对齐：大对象对齐到页大小，避免跨页浪费
size_t alignSize = SizeClass::RoundUp(size);
// 2. 计算需要的连续页数
size_t kPages = alignSize >> PAGE_SHIFT;
// 3. 加全局页锁，保证线程安全
PageCache::GetInstance()->_pageMutex.lock();
// 4. 向 PageCache 申请连续 kPages 页的 span（大页）
span* bigSpan = PageCache::GetInstance()->NewSpan(kPages);
PageCache::GetInstance()->_pageMutex.unlock();
// 5. 页 ID 转换为内存地址（核心：页 ID * 页大小 = 起始地址）
uintptr_t addr = (uintptr_t)bigSpan->_pageId * PAGE_SIZE;
return (void*)addr;
}
// 小对象走 ThreadCache...
}
NewSpan 是大页申请的核心，逻辑为"先查空闲 span→无则向系统申请连续页"：
// PageCache.cpp
span* PageCache::NewSpan(size_t kPages) {
// 1. 优先从对应页数的空闲 span 链表中取
if (!_spanlist[kPages].Empty()) {
span* span = _spanlist[kPages].Pop_front();
// 初始化页 ID 到 span 的映射（仅首尾页，高效）
_idSpanMap[span->_pageId] = span;
_idSpanMap[span->_pageId + span->_n - 1] = span;
span->_isUse = true;
return span;
}
// 2. 无空闲 span，向更大页数的 span 链表找（拆分）
for (size_t i = kPages + 1; i < MAX_PAGE_BUCKETS; ++i) {
if (!_spanlist[i].Empty()) {
span* bigSpan = _spanlist[i].Pop_front();
// 拆分出 kPages 页的 span
span* newSpan = new span;
newSpan->_pageId = bigSpan->_pageId;
newSpan->_n = kPages;
newSpan->_isUse = true;
// 剩余页放回 PageCache
bigSpan->_pageId += kPages;
bigSpan->_n -= kPages;
_spanlist[bigSpan->_n].Push_front(bigSpan);
// 更新映射
_idSpanMap[newSpan->_pageId] = newSpan;
_idSpanMap[newSpan->_pageId + newSpan->_n - 1] = newSpan;
_idSpanMap[bigSpan->_pageId] = bigSpan;
_idSpanMap[bigSpan->_pageId + bigSpan->_n - 1] = bigSpan;
return newSpan;
}
}
// 3. 无任何空闲 span，向系统申请 128 页（大页）
size_t allocPages = MAX_PAGE_BUCKETS - 1;
void* ptr = SystemAlloc(allocPages); // 封装 VirtualAlloc/mmap
span* newSpan = new span;
newSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT; // 地址转页 ID
newSpan->_n = allocPages;
_spanlist[allocPages].Push_front(newSpan);
// 递归拆分（仅 1 层，无栈溢出风险）
return NewSpan(kPages);
}
大页释放的核心是"归还 span 到 PageCache + 双向合并空闲 span"，避免内存碎片化，核心代码：
// ConcurrentAlloc.h - 用户层大对象释放接口
void ConcurrentFree(void* ptr, size_t size) {
assert(ptr);
if (size > MAX_BYTES) {
// 1. 通过地址反查对应的 span（核心：_idSpanMap 映射）
PageCache::GetInstance()->_pageMutex.lock();
span* bigSpan = PageCache::GetInstance()->MapObjectToSpan(ptr);
// 2. 归还 span 到 PageCache 并合并
PageCache::GetInstance()->ReleaseSpanToPageCache(bigSpan);
PageCache::GetInstance()->_pageMutex.unlock();
return;
}
// 小对象走 ThreadCache...
}
// PageCache.cpp - span 合并核心
void PageCache::ReleaseSpanToPageCache(span* obj) {
// 1. 前向合并：合并前一页的空闲 span
while (true) {
PAGE_ID prevId = obj->_pageId - 1;
auto it = _idSpanMap.find(prevId);
if (it == _idSpanMap.end()) break;
span* prevSpan = it->second;
if (prevSpan->_isUse || prevSpan->_n + obj->_n > MAX_PAGE_BUCKETS - 1) break;
// 合并 prevSpan 到当前 span
_spanlist[prevSpan->_n].Erase(prevSpan);
obj->_pageId = prevSpan->_pageId;
obj->_n += prevSpan->_n;
delete prevSpan; // 此处后续用定长内存池优化
}
// 2. 后向合并：合并后一页的空闲 span（逻辑同上）
while (true) {
PAGE_ID nextId = obj->_pageId + obj->_n;
auto it = _idSpanMap.find(nextId);
if (it == _idSpanMap.end()) break;
span* nextSpan = it->second;
if (nextSpan->_isUse || nextSpan->_n + obj->_n > MAX_PAGE_BUCKETS - 1) break;
_spanlist[nextSpan->_n].Erase(nextSpan);
obj->_n += nextSpan->_n;
delete nextSpan; // 此处后续用定长内存池优化
}
// 3. 标记为空闲，更新首尾页映射（高效设计）
obj->_isUse = false;
_spanlist[obj->_n].Push_front(obj);
_idSpanMap[obj->_pageId] = obj;
_idSpanMap[obj->_pageId + obj->_n - 1] = obj;
}
上述代码中，new span 和 delete span 会引入额外开销：new 需要调用构造函数 + 内存分配，delete 需要调用析构函数 + 内存释放，而 span 作为内存池的元对象，创建/销毁频率极高，必须优化。此外，核心目标是替换 malloc 和 new，若内部仍依赖 new/delete，则违背设计初衷。
定长内存池（ObjectPool）的核心是"预分配一块连续内存，按固定大小切割，管理空闲链表"，适用于：
// Fixed-size_memory_pool.h
template<class T>
class ObjectPool {
public:
// 申请对象（脱离 new）
T* New() {
T* obj = nullptr;
// 1. 优先从空闲链表取
if (_freeList) {
obj = (T*)_freeList;
_freeList = *((void**)_freeList); // 头删
} else {
// 2. 空闲链表空，向系统申请大块内存
if (_leftBytes < sizeof(T)) {
_leftBytes = 128 * 1024; // 预分配 128KB
// 按页申请，避免内存碎片
size_t pageNum = _leftBytes / PAGE_SIZE;
_memory = (char*)SystemAlloc(pageNum);
if (_memory == nullptr) throw std::bad_alloc();
}
// 切割内存块
obj = (T*)_memory;
size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
_memory += objSize;
_leftBytes -= objSize;
}
// 3. 定位 new：仅初始化对象，不分配内存（核心）
new(obj)T();
return obj;
}
// 释放对象（脱离 delete）
void Delete(T* obj) {
// 1. 显式析构：仅清理对象，不释放内存
obj->~T();
// 2. 头插到空闲链表
size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
*((void**)obj) = _freeList;
_freeList = obj;
}
private:
char* _memory = nullptr; // 预分配的连续内存块
int _leftBytes = 0; // 剩余可用字节数
void* _freeList = nullptr; // 空闲对象链表
};
将 PageCache 中所有 new span/delete span 替换为 ObjectPool：
// PageCache.h
class PageCache {
private:
ObjectPool<span> _spanPool; // 定长内存池管理 span
public:
span* NewSpan(size_t kPages) {
// 替换 new span
span* newSpan = _spanPool.New();
// ... 其他逻辑
}
void ReleaseSpanToPageCache(span* obj) {
// ... 合并逻辑
// 替换 delete span
_spanPool.Delete(prevSpan);
_spanPool.Delete(nextSpan);
}
};
ThreadCache 是线程私有对象，创建频率高，用 ObjectPool 管理：
// ConcurrentAlloc.h
static __thread ThreadCache* pTLSThreadCache = nullptr;
void* ConcurrentAlloc(size_t size) {
if (size <= MAX_BYTES) {
if (pTLSThreadCache == nullptr) {
// 替换 new ThreadCache
static ObjectPool<ThreadCache> tcPool;
pTLSThreadCache = tcPool.New();
}
return pTLSThreadCache->Allocate(size);
}
// ... 大对象逻辑
}
| 场景 | 原生 malloc/free + new/delete | 高并发内存池（大页 + 定长池） |
|---|---|---|
| 大对象分配耗时 | 高（频繁系统调用） | 低（批量申请 + span 复用） |
| 元对象创建耗时 | 高（new/delete 锁竞争） | 极低（空闲链表无锁） |
| 内存碎片率 | 高（零散分配） | 低（span 合并 + 定长切割） |
| 多线程并发吞吐量 | 低（全局锁竞争） | 高（桶锁 + 线程私有） |
高并发内存池的性能优化，本质是"场景适配 + 开销极致压缩"：
这两个设计的结合，让内存池既保证了大内存的高效管理，又解决了元数据的性能损耗，是 TCMalloc 等工业级内存池的核心精髓，也是高并发场景下内存管理的最优解之一。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online