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

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

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

Part1.內(nèi)存池初印象

1.1什么是內(nèi)存池

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

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

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

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

總的來說，內(nèi)存池是一種強(qiáng)大的工具，它可以幫助我們更有效地管理內(nèi)存。但是，像所有工具一樣，我們需要理解它的優(yōu)點(diǎn)和缺點(diǎn)，以便在適當(dāng)?shù)那闆r下使用它。

圖片

1.2為什么需要內(nèi)存池

⑴內(nèi)存碎片問題

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

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

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

圖片

⑵申請效率問題

例如：我們上學(xué)家里給生活費(fèi)一樣，假設(shè)一學(xué)期的生活費(fèi)是6000塊。

• 方式1：開學(xué)時6000塊直接給你，自己保管，自己分配如何花。
• 方式2：每次要花錢時，聯(lián)系父母，父母轉(zhuǎn)錢。

同樣是6000塊錢，第一種方式的效率肯定更高，因?yàn)榈诙N方式跟父母的溝通交互成本太高了。

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

Part2.定長內(nèi)存池深度剖析

2.1核心原理

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

以一個酒店為例，酒店就像是一個內(nèi)存池 ，酒店的房間就相當(dāng)于內(nèi)存塊。酒店在開業(yè)前（程序運(yùn)行前）就準(zhǔn)備好了一定數(shù)量的房間（申請大塊內(nèi)存并切分） 。當(dāng)有客人來入?。ǔ绦蛏暾垉?nèi)存）時，直接分配一個空閑房間（內(nèi)存塊）給客人；當(dāng)客人退房（程序釋放內(nèi)存）時，房間并不會立即拆除（內(nèi)存不還給系統(tǒng)） ，而是等待下一位客人入?。ㄏ乱淮蝺?nèi)存分配） 。這樣就避免了每次有客人來都要臨時建造房間（每次申請內(nèi)存都向操作系統(tǒng)請求）的麻煩，大大提高了效率。

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

2.2數(shù)據(jù)結(jié)構(gòu)構(gòu)建思路

實(shí)現(xiàn)定長內(nèi)存池，通常需要用到以下幾種關(guān)鍵的數(shù)據(jù)結(jié)構(gòu)：

• 空閑內(nèi)存塊鏈表：這是一個非常重要的數(shù)據(jù)結(jié)構(gòu)，用于管理內(nèi)存池中所有空閑的內(nèi)存塊。鏈表中的每個節(jié)點(diǎn)都代表一個空閑的內(nèi)存塊，節(jié)點(diǎn)中除了包含指向下一個空閑內(nèi)存塊的指針外，還可能包含一些用于標(biāo)識內(nèi)存塊狀態(tài)的信息。當(dāng)程序請求內(nèi)存時，優(yōu)先從這個鏈表中取出空閑內(nèi)存塊進(jìn)行分配；當(dāng)程序釋放內(nèi)存時，將釋放的內(nèi)存塊插入到這個鏈表中。它就像是酒店的空閑房間登記簿，記錄著所有空閑房間的信息，方便快速分配和回收房間。
• 內(nèi)存池結(jié)構(gòu)體：用于記錄內(nèi)存池的整體狀態(tài)和參數(shù)，比如指向大塊內(nèi)存起始地址的指針，記錄內(nèi)存池中空閑內(nèi)存塊鏈表頭指針，記錄內(nèi)存池剩余可用內(nèi)存大小的變量，以及內(nèi)存塊的固定大小等信息。這個結(jié)構(gòu)體就像是酒店的管理系統(tǒng)，記錄著酒店的各種關(guān)鍵信息，如房間總數(shù)、空閑房間列表、酒店總?cè)萘康龋奖銓φ麄€內(nèi)存池進(jìn)行管理和維護(hù)。

這些數(shù)據(jù)結(jié)構(gòu)之間相互協(xié)作，空閑內(nèi)存塊鏈表依賴于內(nèi)存池結(jié)構(gòu)體來獲取內(nèi)存池的基本信息，而內(nèi)存池結(jié)構(gòu)體通過空閑內(nèi)存塊鏈表來管理和維護(hù)內(nèi)存塊的分配與回收，共同實(shí)現(xiàn)了定長內(nèi)存池的高效運(yùn)作。

2.3關(guān)鍵操作函數(shù)解析

實(shí)現(xiàn)定長內(nèi)存池，離不開幾個關(guān)鍵的操作函數(shù)：

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

Part3.定長內(nèi)存池實(shí)現(xiàn)

3.1核心成員變量剖析

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

以一個典型的定長內(nèi)存池實(shí)現(xiàn)為例，通常會包含以下幾個關(guān)鍵的成員變量：

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

_memory 是一個字符指針，它指向程序預(yù)先向操作系統(tǒng)申請的一大塊內(nèi)存。這一大塊內(nèi)存就像是一個大倉庫，后續(xù)所有的內(nèi)存分配和管理都基于它。之所以選擇字符指針，是因?yàn)樽址羔樏看我苿拥牟介L是 1 字節(jié)，非常靈活，便于我們對內(nèi)存進(jìn)行精細(xì)的操作，比如按字節(jié)粒度來切分內(nèi)存塊 。

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

_freeList 是一個指向自由鏈表頭部的指針。自由鏈表是定長內(nèi)存池實(shí)現(xiàn)中的一個重要數(shù)據(jù)結(jié)構(gòu)，它用于管理那些已經(jīng)被歸還但還未被再次分配的內(nèi)存塊。當(dāng)有內(nèi)存塊被釋放時，它會被插入到自由鏈表中；當(dāng)有新的內(nèi)存分配請求時，會優(yōu)先從自由鏈表中獲取內(nèi)存塊。這樣，通過自由鏈表，我們實(shí)現(xiàn)了內(nèi)存塊的復(fù)用，大大提高了內(nèi)存的使用效率 。

3.2內(nèi)存申請（New）流程詳解

當(dāng)程序需要從定長內(nèi)存池中申請內(nèi)存時，整個申請流程是精心設(shè)計(jì)的，旨在高效地滿足內(nèi)存需求。

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

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

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

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

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

申請到新的大塊內(nèi)存后，會從這塊內(nèi)存中分配出一個內(nèi)存塊給調(diào)用者，并相應(yīng)地調(diào)整 _memory 指針的指向和 _remainBytes 的值。

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

最后，使用定位 new（placement new）來初始化對象，調(diào)用對象的構(gòu)造函數(shù)，使分配的內(nèi)存塊成為一個可用的對象。

new(obj)T;
return obj;

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

3.3內(nèi)存釋放（Delete）流程詳解

當(dāng)程序不再需要某個對象，調(diào)用 Delete 函數(shù)釋放內(nèi)存時，定長內(nèi)存池的內(nèi)存釋放流程也有其獨(dú)特的步驟。

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

void Delete(T* obj) {
    obj->~T(); // 調(diào)用對象的析構(gòu)函數(shù)
    // 后續(xù)將對象插回自由鏈表...
}

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

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

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

Part4.代碼實(shí)戰(zhàn)與性能驗(yàn)證

4.1代碼示例展示

下面是一個完整的定長內(nèi)存池的 C++ 實(shí)現(xiàn)代碼，通過這個代碼示例，我們能更直觀地理解定長內(nèi)存池的工作機(jī)制。代碼中關(guān)鍵部分都添加了詳細(xì)注釋，幫助大家理解每一步的操作。

#include <iostream>
#include <vector>

template <class T>
class ObjectPool {
public:
    T* New() {
        T* obj = nullptr;
        // 優(yōu)先從自由鏈表獲取內(nèi)存塊
        if (_freeList) {
            void* next = *((void**)_freeList);
            obj = (T*)_freeList;
            _freeList = next;
        } 
        else {
            // 剩余內(nèi)存不足時，重新申請大塊內(nèi)存
            if (_remainBytes < sizeof(T)) {
                _remainBytes = 128 * 1024; // 申請128KB內(nèi)存，可根據(jù)需求調(diào)整
                _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) {
        // 調(diào)用對象析構(gòu)函數(shù)
        obj->~T();
        // 將釋放的對象插回自由鏈表
        *((T**)obj) = _freeList;
        _freeList = obj;
    }

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

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

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

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

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

    return 0;
}

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

4.2性能測試與結(jié)果分析

為了驗(yàn)證定長內(nèi)存池的性能優(yōu)勢，我們設(shè)計(jì)了一個性能測試實(shí)驗(yàn)，對比系統(tǒng)自帶內(nèi)存分配（new和delete）和定長內(nèi)存池（ObjectPool的New和Delete）在多次申請和釋放內(nèi)存時的時間開銷。

測試代碼如下：

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

// 引入前面定義的ObjectPool類和TestStruct結(jié)構(gòu)體

// 測試系統(tǒng)自帶內(nèi)存分配
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;
}

// 測試定長內(nèi)存池分配
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;
}

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

從結(jié)果可以明顯看出，定長內(nèi)存池在多次申請和釋放內(nèi)存時的時間開銷遠(yuǎn)遠(yuǎn)低于系統(tǒng)自帶的內(nèi)存分配方式。這是因?yàn)槎ㄩL內(nèi)存池減少了系統(tǒng)調(diào)用次數(shù)，避免了內(nèi)存碎片問題，并且通過自由鏈表實(shí)現(xiàn)了內(nèi)存塊的高效復(fù)用，從而大大提高了內(nèi)存分配和釋放的效率，在性能要求較高的場景中具有顯著優(yōu)勢 。