頻繁地分配和回收記憶體會嚴重地降低程式的效能。效能降低的原因在於預設的記憶體管理是通用的。應用程式可能會以某種特定的方式使用記憶體，並且為不需要的功能付出效能上的代價。通過開發專用的記憶體管理器可以解決這個問題。對專用記憶體管理器的設計可以從多個角度考慮。我們至少可以想到兩個方面：大小和併發。

從大小的角度分為以下兩種：

(1)、固定大小：分配固定大小記憶體塊的記憶體管理器。

(2)、可變大小：分配任意大小記憶體塊的記憶體管理器。所請求分配的大小事先是未知的。

類似的，從併發的角度也分為以下兩種：

(1)、單執行緒：記憶體管理器侷限在一個執行緒內。記憶體被一個執行緒使用，並且不越出該執行緒的界限。這種記憶體管理器不涉及相互訪問的多執行緒。

(2)、多執行緒：記憶體管理器被多個執行緒併發地使用。這種實現需要包含互斥執行的程式碼段。無論什麼時候，只能有一個執行緒在執行一個程式碼段。

全域性函式new()和delete()：從設計上來說，預設的記憶體管理器是通用的。當呼叫全域性函式new()和delete()時，我們使用的正是預設記憶體管理器。這兩個函式的實現不能作任何簡化假設。它們在程序範圍內管理記憶體。既然一個程序可能產生多個執行緒，new()和delete()就必須能夠在多執行緒環境中執行。而且，每次請求分配的記憶體大小是不同的。這種靈活性以速度為代價。所做的計算越多，消耗的週期就越多。

通常情況下，客戶端程式碼不需要全域性函式new()和delete()的全部功能。它可能只(或通常)需要特定大小的記憶體塊。客戶端程式碼很可能在單執行緒環境中執行，在這種環境中並不真正需要預設的new()和delete()所提供的併發保護。這樣的話，使用這兩個函式的全部功能就會浪費CPU週期。通過調整記憶體分配策略來更好地匹配特定需求，可以明顯地提高效能。

靈活性以速度的降低為代價.隨著記憶體管理的功能和靈活性的增強,執行速度將降低.

全域性記憶體管理器(由new()和delete()執行)是通用的，因此代價高。

專用記憶體管理器比全域性記憶體管理器快一個數量級以上。

如果主要分配固定大小的記憶體塊，專用的固定大小記憶體管理器將明顯地提升效能。

如果主要分配限於單執行緒的記憶體塊，那麼記憶體管理器也會有類似的效能提高。由於省去了全域性函式new()和delete()必須處理的併發問題，單執行緒記憶體管理器的效能有所提高。

以下是測試程式碼(single_threaded_memory_pool.cpp)：

#include "single_threaded_memory_pool.hpp"
#include <iostream>
#include <chrono>
#include <string>


namespace single_threaded_memory_pool_ {

// reference: 《提高C++效能的程式設計技術》：第六章：單執行緒記憶體池

////////////////////////////////////////////////
class Rational1 {
public:
	Rational1(int a = 0, int b = 1) : n(a), d(b) {}
private:
	int n; // 分子
	int d; // 分母
}; // class Rational1

////////////////////////////////////////////////
// 專用Rational2記憶體管理器
// 為避免頻繁地使用記憶體管理器,Rational2類要維護一個預分配的Rational2物件的靜態連線列表,該列表列出空閒的可用物件.
// 當需要Rational2物件時,可以從空閒列表中取出一個,使用後再把它放回空閒列表以便今後分配. 
// 宣告一個輔助結構來連線空閒列表的相鄰元素
class NextOnFreeList {
public:
	NextOnFreeList* next;
}; // class NextOnFreeList

// 空閒列表被宣告為一個由NextOnFreeList元素組成的列表
class Rational2 {
public:
	Rational2(int a = 0, int b = 1) : n(a),d(b) {}

	inline void* operator new(size_t size);
	inline void operator delete(void* doomed, size_t size);

	static void newMemPool() { expandTheFreeList(); }
	static void deleteMemPool();

private:
	static NextOnFreeList* freeList; // Rational2物件的空閒列表
	static void expandTheFreeList();
	enum { EXPANSION_SIZE = 32};

	int n; // 分子
	int d; // 分母
}; // class Rational2

NextOnFreeList* Rational2::freeList = nullptr;

// new()在空閒列表中分配一個Rational2物件.如果列表為空,則擴充套件列表
inline void* Rational2::operator new(size_t size)
{
	if (nullptr == freeList) { // 如果列表為空,則將其填滿
		expandTheFreeList();
	}

	NextOnFreeList* head = freeList;
	freeList = head->next;

	return head;
}

// delete()把Rational2物件直接新增到空閒列表的頭部,以返回Rational2物件
inline void Rational2::operator delete(void* doomed, size_t size)
{
	NextOnFreeList* head = static_cast<NextOnFreeList*>(doomed);
	head->next = freeList;
	freeList = head;
}

// 當空閒列表用完後,需要從堆上分配更多的Rational2物件.
// Rational2和NextOnFreeList之間的型別轉換是有危險的,必須確保空閒列表的元素足夠大以支援任意一種型別
// 當我們用Rational2物件填充空閒列表時,要記得比較Rational2和NextOnFreeList的大小,並且分配較大的那一個
void Rational2::expandTheFreeList()
{
	// 本質上，expandTheFreeList的實現並不是最優的.因為空閒列表中每增加一個元素，就呼叫一次new. 如果只調用一次new
	// 獲得一大塊記憶體,然後把它切分給多個元素,這樣會更高效。孤立地看，這種想法很正確。然而我們建立記憶體管理器時，
	// 認為它不會頻繁擴充套件和收縮,否則必須重新檢視程式碼實現並修正它

	// 我們必須分配足夠大的物件以包含下一個指標
	size_t size = sizeof(Rational2) > sizeof(NextOnFreeList*) ? sizeof(Rational2) : sizeof(NextOnFreeList*);
	NextOnFreeList* runner = static_cast<NextOnFreeList*>((void*)new char[size]);
	freeList = runner;

	for (int i = 0; i < EXPANSION_SIZE; ++i) {
		runner->next = static_cast<NextOnFreeList*>((void*)new char[size]);
		runner = runner->next;
	}

	runner->next = nullptr;
}

void Rational2::deleteMemPool()
{
	NextOnFreeList* nextPtr;
	for (nextPtr = freeList; nextPtr != nullptr; nextPtr = freeList) {
		freeList = freeList->next;
		delete [] nextPtr;
	}
}

///////////////////////////////////////////////////////////////
// 固定大小物件的記憶體池: 觀察Rational2記憶體管理器的實現，會很清楚地發現記憶體管理邏輯實際上獨立於特定的Rational2類.
// 它唯一依賴的是類物件的大小----這正是用模板實現記憶體池的原因
template<class T>
class MemoryPool1 {
public:
	MemoryPool1(size_t size = EXPANSION_SIZE);
	~MemoryPool1();

	// 從空閒列表中分配T元素
	inline void* alloc(size_t size);
	// 返回T元素到空閒列表中
	inline void free(void* someElement);

private:
	// 空閒列表的下一元素
	MemoryPool1<T>* next;
	// 如果空閒列表為空，按該大小擴充套件它
	enum { EXPANSION_SIZE = 32 };
	// 新增空閒元素至空閒列表
	void expandTheFreeList(int howMany = EXPANSION_SIZE);
};

// 建構函式初始化空閒列表，引數size指定空閒列表的初始化長度
template<class T>
MemoryPool1<T>::MemoryPool1(size_t size)
{
	expandTheFreeList(size);
}

// 解構函式遍歷空閒列表並且刪除所有元素
template<class T>
MemoryPool1<T>::~MemoryPool1()
{
	MemoryPool1<T>* nextPtr = next;
	for (nextPtr = next; nextPtr != nullptr; nextPtr = next) {
		next = next->next;
		delete [] static_cast<char*>(static_cast<void*>(nextPtr));
	}
}

// alloc函式為T元素分配足夠大的空間，如果空閒列表用盡，則呼叫expandThrFreeList函式來擴充它
template<class T>
inline void* MemoryPool1<T>::alloc(size_t size)
{
	if (!next) {
		expandTheFreeList();
	}

	MemoryPool1<T>* head = next;
	next = head->next;

	return head;
}


// free函式把T元素放回空閒列表，以此來釋放它
template<class T>
inline void MemoryPool1<T>::free(void* doomed)
{
	MemoryPool1<T>* head = static_cast<MemoryPool1<T>*>(doomed);
	head->next = next;
	next = head;
}

// expandTheFreeList函式用來向空閒列表新增新元素，首先從堆上分配新元素，然後把它們連線到列表中
// 該函式在空閒列表用盡時被呼叫
template<class T>
void MemoryPool1<T>::expandTheFreeList(int howMany)
{
	// 必須分配足夠大的物件以包含下一個指標
	size_t size = sizeof(T) > sizeof(MemoryPool1<T>*) ? sizeof(T) : sizeof(MemoryPool1<T>*);
	MemoryPool1<T>* runner = static_cast<MemoryPool1<T>*>((void*)(new char[size]));
	next = runner;

	for (int i = 0; i < howMany; ++i) {
		runner->next = static_cast<MemoryPool1<T>*>((void*)(new char[size]));
		runner = runner->next;
	}

	runner->next = nullptr;
}

// Rational3類不再需要維護它自己的空閒列表，這項任務委託給了MemoryPool1類
class Rational3 {
public:
	Rational3(int a = 0, int b = 1) : n(a),d(b) {}

	void* operator new(size_t size) { return memPool->alloc(size); }
	void operator delete(void* doomed, size_t size) { memPool->free(doomed); }
	static void newMemPool() { memPool = new MemoryPool1<Rational3>; }
	static void deleteMemPool() { delete memPool; }

private:
	int n; // 分子
	int d; // 分母
	static MemoryPool1<Rational3>* memPool;
};

MemoryPool1<Rational3>* Rational3::memPool = nullptr;

/////////////////////////////////////////////////////////////////////
// 單執行緒可變大小記憶體管理器: 
// MemoryChunk類取代之前版本中使用的NextOnFreeList類，它用來把不同大小的記憶體塊連線起來形成塊序列
class MemoryChunk {
public:
	MemoryChunk(MemoryChunk* nextChunk, size_t chunkSize);
	// 解構函式釋放建構函式獲得的記憶體空間
	~MemoryChunk() { delete [] mem; }

	inline void* alloc(size_t size);
	inline void free(void* someElement);

	// 指向列表下一記憶體塊的指標
	MemoryChunk* nextMemChunk() { return next; }
	// 當前記憶體塊剩餘空間大小
	size_t spaceAvailable() { return chunkSize - bytesAlreadyAllocated; }
	// 這是一個記憶體塊的預設大小
	enum { DEFAULT_CHUNK_SIZE = 4096 };

private:
	MemoryChunk* next;
	void* mem;

	// 一個記憶體塊的預設大小
	size_t chunkSize;
	// 當前記憶體塊中已分配的位元組數
	size_t bytesAlreadyAllocated;
};

// 建構函式首先確定記憶體塊的適當大小，然後根據這個大小從堆上分配私有儲存空間
// MemoryChunk將next成員指向輸入引數nextChunk, nextChunk是列表先前的頭部
MemoryChunk::MemoryChunk(MemoryChunk* nextChunk, size_t reqSize)
{
	chunkSize = (reqSize > DEFAULT_CHUNK_SIZE) ? reqSize : DEFAULT_CHUNK_SIZE;
	next = nextChunk;
	bytesAlreadyAllocated = 0;
	mem = new char[chunkSize];
}

// alloc函式處理記憶體分配請求，它返回一個指標，該指標指向mem所指向的MemoryChunk私有儲存空間中的可用空間。
// 該函式通過更新該塊中已分配的位元組數來記錄可用空間的大小
void* MemoryChunk::alloc(size_t requestSize)
{
	void* addr = static_cast<void*>(static_cast<char*>(mem) + bytesAlreadyAllocated);
	bytesAlreadyAllocated += requestSize;

	return addr;
}

// 在該實現中，不用擔心空閒記憶體段的釋放。當物件被刪除後，整個記憶體塊將被釋放並且返回到堆上
inline void MemoryChunk::free(void* doomed)
{
}

// MemoryChunk只是一個輔助類，ByteMemoryPoll類用它來實現可變大小的記憶體管理
class ByteMemoryPool {
public:
	ByteMemoryPool(size_t initSize = MemoryChunk::DEFAULT_CHUNK_SIZE);
	~ByteMemoryPool();

	// 從私有記憶體池分配記憶體
	inline  void* alloc(size_t size);
	// 釋放先前從記憶體池中分配的記憶體
	inline void free(void* someElement);

private:
	// 記憶體塊列表，它是我們的私有儲存空間
	MemoryChunk* listOfMemoryChunks = nullptr;
	// 向我們的私有儲存空間新增一個記憶體塊
	void expandStorage(size_t reqSize);
};

// 雖然記憶體塊列表可能包含多個塊，但只有第一塊擁有可用於分配的記憶體。其它塊表示已分配的記憶體。
// 列表的首個元素是唯一能夠分配可以記憶體的塊。

// 建構函式接收initSize引數來設定一個記憶體塊的大小，即構造函數借此來設定單個記憶體塊的大小。
// expandStorage方法使listOfMemoryChunks指向一個已分配的MemoryChunk物件
// 建立ByteMemoryPool物件，生成私有儲存空間
ByteMemoryPool::ByteMemoryPool(size_t initSize)
{
	expandStorage(initSize);
}

// 解構函式遍歷記憶體塊列表並且刪除它們
ByteMemoryPool::~ByteMemoryPool()
{
	MemoryChunk* memChunk = listOfMemoryChunks;

	while (memChunk) {
		listOfMemoryChunks = memChunk->nextMemChunk();
		delete memChunk;
		memChunk = listOfMemoryChunks;
	}
}

// alloc函式確保有足夠的可用空間，而把分配任務託付給列表頭的MemoryChunk
void* ByteMemoryPool::alloc(size_t requestSize)
{
	size_t space = listOfMemoryChunks->spaceAvailable();
	if (space < requestSize) {
		expandStorage(requestSize);
	}

	return listOfMemoryChunks->alloc(requestSize);
}

// 釋放之前分配的記憶體的任務被委派給列表頭部的MemoryChunk來完成
// MemoryChunk::free不做任何事情，因為ByteMemoryPool的實現不會重用之前分配的記憶體。如果需要更多記憶體，
// 我們將建立新的記憶體塊以便今後分配使用。在記憶體池被銷燬時，記憶體釋放回堆中。ByteMemoryPool解構函式
// 釋放所有的記憶體塊到堆中
inline void ByteMemoryPool::free(void* doomed)
{
	listOfMemoryChunks->free(doomed);
}

// 若遇到記憶體塊用盡這種不太可能的情況，我們通過建立新的記憶體塊並把它新增到記憶體塊列表的頭部來擴充套件它
void ByteMemoryPool::expandStorage(size_t reqSize)
{
	listOfMemoryChunks = new MemoryChunk(listOfMemoryChunks, reqSize);
}

class Rational4 {
public:
	Rational4(int a = 0, int b = 1) : n(a),d(b) {}

	void* operator new(size_t size) { return memPool->alloc(size); }
	void operator delete(void* doomed, size_t size) { memPool->free(doomed); }

	static void newMemPool() { memPool = new ByteMemoryPool; }
	static void deleteMemPool() { delete memPool; }

private:
	int n; // 分子
	int d; // 分母
	static ByteMemoryPool* memPool;
};

ByteMemoryPool* Rational4::memPool = nullptr;

/////////////////////////////////////////////////////////////////
int test_single_threaded_memory_pool_1()
{
	using namespace std::chrono;
	high_resolution_clock::time_point time_start, time_end;
	const int cycle_number1{10000}, cycle_number2{1000};

{ // 測試全域性函式new()和delete()的基準效能
	Rational1* array[cycle_number2];

	time_start = high_resolution_clock::now();
	for (int j =0; j < cycle_number1; ++j) {
		for (int i =0; i < cycle_number2; ++i) {
			array[i] = new Rational1(i);
		}

		for (int i = 0; i < cycle_number2; ++i) {
			delete array[i];
		}	
	}
	time_end = high_resolution_clock::now();

	fprintf(stdout, "global function new/delete time spent: %f seconds\n",(duration_cast<duration<double>>(time_end - time_start)).count());
}

{ // 專用Rational2記憶體管理器測試
	Rational2* array[cycle_number2];

	time_start = high_resolution_clock::now();
	Rational2::newMemPool();

	for (int j = 0; j < cycle_number1; ++j) {
		for (int i = 0; i < cycle_number2; ++i) {
			array[i] = new Rational2(i);
		}

		for (int i = 0; i < cycle_number2; ++i) {
			delete array[i];
		}
	}

	Rational2::deleteMemPool();
	time_end = high_resolution_clock::now();

	fprintf(stdout, "specialized rational2 memory manager time spent: %f seconds\n",(duration_cast<duration<double>>(time_end - time_start)).count());	
}

{ // 固定大小物件的記憶體池測試
	Rational3* array[cycle_number2];

	time_start = high_resolution_clock::now();
	Rational3::newMemPool();

	for (int j = 0; j < cycle_number1; ++j) {
		for (int i = 0; i < cycle_number2; ++i) {
			array[i] = new Rational3(i);
		}

		for (int i = 0; i < cycle_number2; ++i) {
			delete array[i];
		}
	}

	Rational3::deleteMemPool();
	time_end = high_resolution_clock::now();

	fprintf(stdout, "fixed-size object memory pool time spent: %f seconds\n",(duration_cast<duration<double>>(time_end - time_start)).count());	
}

{ // 單執行緒可變大小記憶體管理器測試
	Rational4* array[cycle_number2];

	time_start = high_resolution_clock::now();
	Rational4::newMemPool();

	for (int j = 0; j < cycle_number1; ++j) {
		for (int i = 0; i < cycle_number2; ++i) {
			array[i] = new Rational4(i);
		}

		for (int i = 0; i < cycle_number2; ++i) {
			delete array[i];
		}
	}

	Rational4::deleteMemPool();
	time_end = high_resolution_clock::now();

	fprintf(stdout, "single-threaded variable-size memory manager time spent: %f seconds\n",(duration_cast<duration<double>>(time_end - time_start)).count());	

}
	return 0;
}

} // namespace single_threaded_memory_pool_
 

執行結果如下：

GitHub： https://github.com/fengbingchun/Messy_Test