C++ 高并发内存池实战：内存释放流程详解

何时更新 _idSpanMap？Span 在刚分配时是连续的大块内存，尚未切分，此时无需记录具体对象。只有当 CentralCache 申请并切分后，小块内存才需要关联 Span。这个动作发生在 NewSpan 函数中。

// 获取一个 K 页的 span
Span* PageCache::NewSpan(size_t k) {
    assert(k > 0 && k < NPAGES);
    
    // 先检查第 k 个桶里面有没有 span
    if (!_spanLists[k].Empty()) {
        return _spanLists[k].PopFront();
    }
    
    // 检查一下后面的桶里面有没有 span，如果有可以把它进行切分
    for (size_t i = k + 1; i < NPAGES; ++i) {
        if (!_spanLists[i].Empty()) {
            Span* nSpan = _spanLists[i].PopFront();
            Span* kSpan = new Span;
            
            // 在 nSpan 的头部切一个 k 页下来
            kSpan->_pageId = nSpan->_pageId;
            kSpan->_n = k;
            nSpan->_pageId += k;
            nSpan->_n -= k;
            
            _spanLists[nSpan->_n].PushFront(nSpan);
            
            // 存储 nSpan 的首位页号跟 nSpan 映射，方便 page cache 回收内存时进行的合并查找
            _idSpanMap[nSpan->_pageId] = nSpan;
            _idSpanMap[nSpan->_pageId + nSpan->_n - 1] = nSpan;
            
            // 建立 id 和 span 的映射，方便 central cache 回收小块内存时，查找对应的 span
            for (PAGE_ID i = 0; i < kSpan->_n; ++i) {
                _idSpanMap[kSpan->_pageId + i] = kSpan;
            }
            
            return kSpan;
        }
    }
    
    // 走到这个位置就说明后面没有大页的 span 了
    // 这时就去找堆要一个 128 页的 span
    Span* bigSpan = new Span;
    void* ptr = SystemAlloc(NPAGES - 1);
    bigSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT;
    bigSpan->_n = NPAGES - 1;
    _spanLists[bigSpan->_n].PushFront(bigSpan);
    
    return NewSpan(k);
}

ThreadCache 内存回收与释放

ThreadCache 负责线程级别的缓存管理。当它收回内存块后，会将这些块串在对应的哈希桶内。一旦链表长度超过阈值，说明本地缓存已饱和，需要将一批内存归还给 CentralCache。

void ThreadCache::Deallocate(void* ptr, size_t size) {
    assert(ptr);
    assert(size <= MAX_BYTES);
    
    // 找对映射的自由链表桶，对象插入进入
    size_t index = SizeClass::Index(size);
    _freeLists[index].Push(ptr);
    
    // 当链表长度大于一次批量申请的内存时就开始还一段 list 给 central cache
    if (_freeLists[index].Size() >= _freeLists[index].MaxSize()) {
        ListTooLong(_freeLists[index], size);
    }
}

void ThreadCache::ListTooLong(FreeList& list, size_t size) {
    void* start = nullptr;
    void* end = nullptr;
    
    // 把过长的内存块拿出
    list.PopRange(start, end, list.MaxSize());
    
    // 还给 CentralCache
    CentralCache::GetInstance()->ReleaseListToSpans(start, size);
}

CentralCache 内存回收与释放

CentralCache 作为中间层，接收 ThreadCache 归还的内存块。它的处理逻辑比较关键：

1. 通过 PageCache 内的哈希表查找内存块对应的 Span。
2. 将内存块串回该 Span 的空闲链表。
3. 如果该 Span 没有任何内存块被使用（即所有小块都回来了），则直接将整个 Span 归还给 PageCache。

void CentralCache::ReleaseListToSpans(void* start, size_t size) {
    size_t index = SizeClass::Index(size);
    _spanLists[index]._mtx.lock();
    
    while (start) {
        void* next = NextObj(start);
        Span* span = PageCache::GetInstance()->MapObjectToSpan(start);
        
        NextObj(start) = span->_freeList;
        span->_freeList = start;
        span->_useCount--;
        
        // 说明 span 的切分出去的所有小块内存都回来了
        // 这个 span 就可以再回收给 page cache，pagecache 可以再尝试去做前后页的合并
        if (span->_useCount == 0) {
            _spanLists[index].Erase(span);
            span->_freeList = nullptr;
            span->_next = nullptr;
            span->_prev = nullptr;
            
            // 释放 span 给 page cache 时，使用 page cache 的锁就可以了
            // 这时把桶锁解掉
            _spanLists[index]._mtx.unlock();
            PageCache::GetInstance()->_pageMtx.lock();
            PageCache::GetInstance()->ReleaseSpanToPageCache(span);
            PageCache::GetInstance()->_pageMtx.unlock();
            _spanLists[index]._mtx.lock();
        }
        
        start = next;
    }
    
    _spanLists[index]._mtx.unlock();
}

PageCache 内存回收与释放

PageCache 处于底层，负责物理内存的管理。当它收回 CentralCache 归还的 Span 时，核心目标是减少碎片。策略是向前和向后尝试合并相邻的可用 Span，直到无法合并为止。

void PageCache::ReleaseSpanToPageCache(Span* span) {
    // 对 span 前后的页，尝试进行合并，缓解内存碎片问题
    while (1) {
        PAGE_ID prevId = span->_pageId - 1;
        auto ret = _idSpanMap.find(prevId);
        
        // 前面的页号没有，不合并了
        if (ret == _idSpanMap.end()) {
            break;
        }
        
        // 前面相邻页的 span 在使用，不合并了
        Span* prevSpan = ret->second;
        if (prevSpan->_isUse == true) {
            break;
        }
        
        // 合并出超过 128 页的 span 没办法管理，不合并了
        if (prevSpan->_n + span->_n > NPAGES - 1) {
            break;
        }
        
        span->_pageId = prevSpan->_pageId;
        span->_n += prevSpan->_n;
        _spanLists[prevSpan->_n].Erase(prevSpan);
        delete prevSpan;
    }
    
    // 向后合并
    while (1) {
        PAGE_ID nextId = span->_pageId + span->_n;
        auto ret = _idSpanMap.find(nextId);
        
        if (ret == _idSpanMap.end()) {
            break;
        }
        
        Span* nextSpan = ret->second;
        if (nextSpan->_isUse == true) {
            break;
        }
        
        if (nextSpan->_n + span->_n > NPAGES - 1) {
            break;
        }
        
        span->_n += nextSpan->_n;
        _spanLists[nextSpan->_n].Erase(nextSpan);
        delete nextSpan;
    }
    
    _spanLists[span->_n].PushFront(span);
    span->_isUse = false;
    _idSpanMap[span->_pageId] = span;
    _idSpanMap[span->_pageId + span->_n - 1] = span;
}