在日常開發過程中，大家有沒有遇到過這樣的場景：程序在運行時頻繁地進行內存分配與釋放操作 ，隨著時間的推移，程序的運行速度越來越慢，內存占用卻不斷攀升，甚至還可能出現內存分配失敗的異常。這其實就是內存分配過程中常見的性能問題和內存碎片問題在作祟。

當我們使用常規的內存分配方式，比如 C++ 里的new、delete ，C 里的malloc、free ，每次申請的內存塊大小不定。在頻繁操作下，就好比在一塊完整的土地上隨意挖坑（分配內存）和填坑（釋放內存） ，最后土地變得坑洼不平（內存碎片化）。這些碎片化的內存會導致后續的內存分配操作效率降低，甚至在內存總量充足的情況下，也可能因為無法找到連續的足夠大的內存塊而導致分配失敗。

假設我們在開發一個游戲，游戲中有大量的小對象頻繁地創建和銷毀，比如每一幀都要生成和刪除大量的子彈、特效粒子等。如果使用常規內存分配方式，隨著游戲的運行，內存碎片會越來越多，最終可能導致游戲卡頓，嚴重影響玩家體驗。那有沒有什么好的解決辦法呢？今天就給大家介紹一種高效的內存管理方案 —— 定長內存池 ，它就像是一位貼心的管家，能夠幫助我們更合理地管理內存，提升程序性能。

Part1.內存池初印象

1.1什么是內存池

內存池，簡單來說，就是在程序運行前或者運行初期，預先從操作系統申請一塊較大的連續內存空間作為 “儲備庫” 。當程序中需要分配內存時，不是直接向操作系統請求，而是從這個預先創建好的內存池中獲取；當程序釋放內存時，也不是立即歸還給操作系統，而是將其放回內存池，等待下一次被分配使用。

與常規的內存分配方式相比，內存池就像是一個有序的倉庫，而常規分配方式則像一個雜亂的集市。在集市里（常規內存分配），每次買賣（內存分配與釋放）的貨物（內存塊）大小、位置都不固定，久而久之，集市就變得混亂不堪，難以找到合適的貨物（內存碎片化） 。而在倉庫（內存池）中，貨物（內存塊）被分類存放，需要時能快速找到并取用，歸還時也能準確放回原位 ，極大地提高了效率。

內存池最大的優勢在于減少內存碎片。由于內存池中的內存塊大小通常是固定的或者預先規劃好的，在頻繁的分配和釋放過程中，不會像常規分配那樣產生大量無法利用的小內存碎片。這就好比將物品整齊地放在固定大小的貨架上（內存塊規整排列） ，而不是隨意擺放，從而避免了空間的浪費（減少內存碎片） 。

內存池的分配效率更高。常規內存分配每次都需要與操作系統進行交互，這涉及到復雜的系統調用和內核操作，開銷較大。而內存池的分配和釋放操作都在用戶態進行，不需要頻繁陷入內核，就像在自己家里找東西（內存池內分配）肯定比去商店買東西（向操作系統申請內存）要快得多，大大節省了時間開銷，提高了程序的運行速度。

總的來說，內存池是一種強大的工具，它可以幫助我們更有效地管理內存。但是，像所有工具一樣，我們需要理解它的優點和缺點，以便在適當的情況下使用它。

圖片

1.2為什么需要內存池

⑴內存碎片問題

造成堆利用率很低的一個主要原因就是內存碎片化。如果有未使用的存儲器，但是這塊存儲器不能用來滿足分配的請求，這時候就會產生內存碎片化問題。內存碎片化分為內部碎片和外部碎片。

內部碎片：內部碎片是指一個已分配的塊比有效載荷大時發生的。(假設以前分配了10個大小的字節，現在只用了5個字節，則剩下的5個字節就會內碎片)。內部碎片的大小就是已經分配的塊的大小和他們的有效載荷之差的和。因此內部碎片取決于以前請求內存的模式和分配器實現(對齊的規則)的模式。

外部碎片：假設系統依次分配了16byte、8byte、16byte、4byte，還剩余8byte未分配。這時要分配一個24byte的空間，操作系統回收了一個上面的兩個16byte，總的剩余空間有40byte，但是卻不能分配出一個連續24byte的空間，這就是外碎片問題。

圖片

⑵申請效率問題

例如：我們上學家里給生活費一樣，假設一學期的生活費是6000塊。

• 方式1：開學時6000塊直接給你，自己保管，自己分配如何花。
• 方式2：每次要花錢時，聯系父母，父母轉錢。

同樣是6000塊錢，第一種方式的效率肯定更高，因為第二種方式跟父母的溝通交互成本太高了。

同樣的道理，程序就像是上學的我們，操作系統就像父母，頻繁申請內存的場景下，每次需要內存，都像系統申請效率必然有影響。

Part2.定長內存池深度剖析

2.1核心原理

定長內存池的核心原理可以簡單概括為：預先向操作系統申請一塊較大的連續內存空間，然后將這塊大內存按照固定的大小切割成多個小的內存塊 。當程序需要分配內存時，直接從這些預先切分好的固定大小的內存塊中取出一個返回給程序使用；當程序釋放內存時，將釋放的內存塊重新回收到內存池中，而不是立即歸還給操作系統，以便后續再次分配使用。

以一個酒店為例，酒店就像是一個內存池 ，酒店的房間就相當于內存塊。酒店在開業前（程序運行前）就準備好了一定數量的房間（申請大塊內存并切分） 。當有客人來入住（程序申請內存）時，直接分配一個空閑房間（內存塊）給客人；當客人退房（程序釋放內存）時，房間并不會立即拆除（內存不還給系統） ，而是等待下一位客人入住（下一次內存分配） 。這樣就避免了每次有客人來都要臨時建造房間（每次申請內存都向操作系統請求）的麻煩，大大提高了效率。

假設我們要開發一個網絡通信程序，其中會頻繁地發送和接收固定大小的數據包，比如每個數據包大小為 1024 字節。如果使用常規內存分配方式，每次發送或接收數據包都要向操作系統申請和釋放 1024 字節的內存，開銷很大。而使用定長內存池，我們可以預先申請一大塊內存，將其切分成多個 1024 字節的小塊。當需要發送或接收數據包時，直接從內存池中獲取一個 1024 字節的內存塊，使用完后再放回內存池，極大地提高了內存分配和釋放的效率，也減少了內存碎片的產生。

2.2數據結構構建思路

實現定長內存池，通常需要用到以下幾種關鍵的數據結構：

• 空閑內存塊鏈表：這是一個非常重要的數據結構，用于管理內存池中所有空閑的內存塊。鏈表中的每個節點都代表一個空閑的內存塊，節點中除了包含指向下一個空閑內存塊的指針外，還可能包含一些用于標識內存塊狀態的信息。當程序請求內存時，優先從這個鏈表中取出空閑內存塊進行分配；當程序釋放內存時，將釋放的內存塊插入到這個鏈表中。它就像是酒店的空閑房間登記簿，記錄著所有空閑房間的信息，方便快速分配和回收房間。
• 內存池結構體：用于記錄內存池的整體狀態和參數，比如指向大塊內存起始地址的指針，記錄內存池中空閑內存塊鏈表頭指針，記錄內存池剩余可用內存大小的變量，以及內存塊的固定大小等信息。這個結構體就像是酒店的管理系統，記錄著酒店的各種關鍵信息，如房間總數、空閑房間列表、酒店總容量等，方便對整個內存池進行管理和維護。

這些數據結構之間相互協作，空閑內存塊鏈表依賴于內存池結構體來獲取內存池的基本信息，而內存池結構體通過空閑內存塊鏈表來管理和維護內存塊的分配與回收，共同實現了定長內存池的高效運作。

2.3關鍵操作函數解析

實現定長內存池，離不開幾個關鍵的操作函數：

1. 初始化內存池函數：這個函數的主要功能是向操作系統申請大塊內存，并對內存池的各種數據結構進行初始化設置。在申請內存時，需要考慮內存對齊等問題，以確保內存的高效使用。同時，要將申請到的大塊內存按照固定大小切分成多個小內存塊，并將這些小內存塊組織成空閑內存塊鏈表。比如在 C++ 中，我們可以使用malloc函數來申請大塊內存，然后通過指針運算將其切分成小內存塊。初始化函數就像是酒店開業前的準備工作，要準備好房間、登記好房間信息等，為后續的運營做好鋪墊。
2. 分配內存函數：當程序調用這個函數申請內存時，它首先會檢查空閑內存塊鏈表是否為空。如果鏈表不為空，說明有空閑的內存塊可以直接分配，函數就從鏈表中取出一個空閑內存塊返回給程序；如果鏈表為空，說明當前內存池中沒有空閑內存塊了，此時需要判斷內存池剩余的內存空間是否足夠再分配一個固定大小的內存塊。如果足夠，就從剩余內存中分配一個內存塊返回；如果不夠，就需要重新向操作系統申請大塊內存，然后重復上述過程。在分配內存時，還需要注意一些邊界條件和錯誤處理，比如內存申請失敗的情況。它就像是酒店的前臺接待員，根據客人的需求分配空閑房間，如果沒有空閑房間，要判斷是否有可調配的房間或者是否需要增加房間。
3. 釋放內存函數：當程序不再使用某個內存塊并調用這個函數釋放內存時，函數會將釋放的內存塊重新插入到空閑內存塊鏈表中。在插入之前，可能需要進行一些額外的操作，比如檢查內存塊的合法性，確保內存塊確實是從當前內存池中分配出去的。同時，還可能需要更新內存池的一些狀態信息，如剩余可用內存大小等。釋放內存函數就像是酒店的退房處理流程，客人退房后，要將房間重新登記為空閑狀態，以便下一位客人入住。

Part3.定長內存池實現

3.1核心成員變量剖析

要深入理解定長內存池的工作原理，首先得剖析其核心成員變量，它們就像是定長內存池這座大廈的基石，支撐著整個內存管理體系的運行。

以一個典型的定長內存池實現為例，通常會包含以下幾個關鍵的成員變量：

template <class T>
class ObjectPool {
public:
    // 省略其他成員函數...
private:
    char* _memory = nullptr; // 指向申請的大塊內存
    size_t _remainBytes = 0; // 記錄剩余內存字節數
    T* _freeList = nullptr;  // 管理歸還內存的自由鏈表頭指針
};

_memory 是一個字符指針，它指向程序預先向操作系統申請的一大塊內存。這一大塊內存就像是一個大倉庫，后續所有的內存分配和管理都基于它。之所以選擇字符指針，是因為字符指針每次移動的步長是 1 字節，非常靈活，便于我們對內存進行精細的操作，比如按字節粒度來切分內存塊 。

_remainBytes 用于記錄當前 _memory 所指向的大塊內存中還剩余多少字節可供分配。在內存分配過程中，每分配出一個固定大小的內存塊，_remainBytes 的值就會相應減少。通過這個變量，我們可以清楚地知道當前內存池中還有多少可用內存，以便在需要時決定是否要重新向操作系統申請內存。

_freeList 是一個指向自由鏈表頭部的指針。自由鏈表是定長內存池實現中的一個重要數據結構，它用于管理那些已經被歸還但還未被再次分配的內存塊。當有內存塊被釋放時，它會被插入到自由鏈表中；當有新的內存分配請求時，會優先從自由鏈表中獲取內存塊。這樣，通過自由鏈表，我們實現了內存塊的復用，大大提高了內存的使用效率 。

3.2內存申請（New）流程詳解

當程序需要從定長內存池中申請內存時，整個申請流程是精心設計的，旨在高效地滿足內存需求。

①自由鏈表優先：當調用 New 函數申請內存時，定長內存池會首先檢查自由鏈表是否有可用的內存塊。這就好比你去圖書館借書，會先看看圖書館的自助還書區有沒有你需要的書。如果自由鏈表不為空，說明有之前歸還的內存塊可供使用，此時會采用頭刪的方式從自由鏈表中獲取一個內存塊。具體實現如下：

T* New() {
    T* obj = nullptr;
    if (_freeList) {
        // 從自由鏈表頭刪一個對象
        void* next = *((void**)_freeList);
        obj = (T*)_freeList;
        _freeList = next;
        return obj;
    }
    // 后續處理大塊內存分配...
}

通過這種方式，我們能夠快速地滿足內存分配需求，避免了從大塊內存中切分內存塊的開銷，提高了內存分配的效率。

②大塊內存分配：如果自由鏈表中沒有可用的內存塊，就需要從預先申請的大塊內存中分配。首先，會判斷當前大塊內存中剩余的字節數（即 _remainBytes ）是否足夠分配一個固定大小的內存塊（大小為 sizeof(T) ）。如果剩余字節數不足，就需要重新向操作系統申請一大塊內存。申請內存的函數通常會封裝系統調用，例如在 Windows 下可以使用 VirtualAlloc 函數，在 Linux 下可以使用 brk 或 mmap 函數。

if (_remainBytes < sizeof(T)) {
    _remainBytes = 128 * 1024; // 重新申請內存，這里以申請128KB為例
    _memory = (char*)malloc(_remainBytes);
    if (_memory == nullptr) {
        throw std::bad_alloc(); // 內存申請失敗，拋出異常
    }
}

申請到新的大塊內存后，會從這塊內存中分配出一個內存塊給調用者，并相應地調整 _memory 指針的指向和 _remainBytes 的值。

obj = (T*)_memory;
_memory += sizeof(T);
_remainBytes -= sizeof(T);

最后，使用定位 new（placement new）來初始化對象，調用對象的構造函數，使分配的內存塊成為一個可用的對象。

new(obj)T;
return obj;

這樣，通過自由鏈表優先和大塊內存分配相結合的方式，定長內存池能夠高效地滿足程序的內存申請需求。

3.3內存釋放（Delete）流程詳解

當程序不再需要某個對象，調用 Delete 函數釋放內存時，定長內存池的內存釋放流程也有其獨特的步驟。

首先，會調用對象的析構函數，清理對象內部的資源，確保對象的狀態是安全可回收的。這一步非常重要，就像你歸還圖書館的書之前，要確保書的內容完整，沒有缺失頁或損壞。

void Delete(T* obj) {
    obj->~T(); // 調用對象的析構函數
    // 后續將對象插回自由鏈表...
}

然后，將釋放的對象頭插回自由鏈表中。在將對象插回自由鏈表時，需要注意不同平臺下指針大小的差異。在 32 位系統中，指針大小通常為 4 字節；在 64 位系統中，指針大小通常為 8 字節。為了處理這種差異，我們可以使用二級指針解引用的方式。具體來說，將對象指針轉換為二級指針（T** ），然后進行解引用操作。這樣，無論在 32 位還是 64 位系統中，解引用操作都會正確地處理指針大小，將對象正確地插入自由鏈表。

*((T**)obj) = _freeList;
_freeList = obj;

通過這種方式，釋放的內存塊被重新納入自由鏈表的管理，以便后續再次被分配使用。這種內存釋放流程不僅保證了內存的正確回收和復用，還巧妙地處理了不同平臺下指針大小的兼容性問題，使得定長內存池的實現更加健壯和通用 。

Part4.代碼實戰與性能驗證

4.1代碼示例展示

下面是一個完整的定長內存池的 C++ 實現代碼，通過這個代碼示例，我們能更直觀地理解定長內存池的工作機制。代碼中關鍵部分都添加了詳細注釋，幫助大家理解每一步的操作。

#include <iostream>
#include <vector>

template <class T>
class ObjectPool {
public:
    T* New() {
        T* obj = nullptr;
        // 優先從自由鏈表獲取內存塊
        if (_freeList) {
            void* next = *((void**)_freeList);
            obj = (T*)_freeList;
            _freeList = next;
        } 
        else {
            // 剩余內存不足時，重新申請大塊內存
            if (_remainBytes < sizeof(T)) {
                _remainBytes = 128 * 1024; // 申請128KB內存，可根據需求調整
                _memory = (char*)malloc(_remainBytes);
                if (_memory == nullptr) {
                    throw std::bad_alloc();
                }
            }
            obj = (T*)_memory;
            _memory += sizeof(T);
            _remainBytes -= sizeof(T);
        }
        // 使用定位new初始化對象
        new(obj)T;
        return obj;
    }

    void Delete(T* obj) {
        // 調用對象析構函數
        obj->~T();
        // 將釋放的對象插回自由鏈表
        *((T**)obj) = _freeList;
        _freeList = obj;
    }

private:
    char* _memory = nullptr; // 指向申請的大塊內存
    size_t _remainBytes = 0; // 記錄剩余內存字節數
    T* _freeList = nullptr;  // 管理歸還內存的自由鏈表頭指針
};

// 測試用的簡單結構體
struct TestStruct {
    int data;
    TestStruct() : data(0) {}
};

int main() {
    ObjectPool<TestStruct> pool;
    std::vector<TestStruct*> objects;

    // 申請內存塊
    for (size_t i = 0; i < 10; ++i) {
        TestStruct* obj = pool.New();
        objects.push_back(obj);
    }

    // 釋放內存塊
    for (size_t i = 0; i < 10; ++i) {
        pool.Delete(objects[i]);
    }

    return 0;
}

在這段代碼中，ObjectPool類實現了定長內存池的基本功能。New函數負責內存的申請，首先檢查自由鏈表中是否有可用內存塊，如果有則直接使用；若沒有則從預先申請的大塊內存中分配，當大塊內存不足時，會重新申請。Delete函數負責內存的釋放，先調用對象的析構函數清理資源，然后將對象插回自由鏈表 。TestStruct結構體用于測試內存池的功能，在main函數中，我們通過循環申請和釋放內存塊，驗證定長內存池的正確性 。

4.2性能測試與結果分析

為了驗證定長內存池的性能優勢，我們設計了一個性能測試實驗，對比系統自帶內存分配（new和delete）和定長內存池（ObjectPool的New和Delete）在多次申請和釋放內存時的時間開銷。

測試代碼如下：

#include <iostream>
#include <vector>
#include <chrono>

// 引入前面定義的ObjectPool類和TestStruct結構體

// 測試系統自帶內存分配
void testSystemAllocation() {
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<TestStruct*> objects;
    for (size_t i = 0; i < 100000; ++i) {
        TestStruct* obj = new TestStruct;
        objects.push_back(obj);
    }
    for (size_t i = 0; i < 100000; ++i) {
        delete objects[i];
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    std::cout << "System allocation time: " << duration << " ms" << std::endl;
}

// 測試定長內存池分配
void testObjectPoolAllocation() {
    ObjectPool<TestStruct> pool;
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<TestStruct*> objects;
    for (size_t i = 0; i < 100000; ++i) {
        TestStruct* obj = pool.New();
        objects.push_back(obj);
    }
    for (size_t i = 0; i < 100000; ++i) {
        pool.Delete(objects[i]);
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    std::cout << "Object pool allocation time: " << duration << " ms" << std::endl;
}

int main() {
    testSystemAllocation();
    testObjectPoolAllocation();
    return 0;
}

在這個測試中，我們分別進行了 100000 次內存的申請和釋放操作，使用std::chrono庫來精確測量時間。通過多次運行測試代碼，得到如下結果（實際結果可能因機器性能和編譯器不同而有所差異）：

從結果可以明顯看出，定長內存池在多次申請和釋放內存時的時間開銷遠遠低于系統自帶的內存分配方式。這是因為定長內存池減少了系統調用次數，避免了內存碎片問題，并且通過自由鏈表實現了內存塊的高效復用，從而大大提高了內存分配和釋放的效率，在性能要求較高的場景中具有顯著優勢 。