C++中內(nèi)存池的原理及實(shí)現(xiàn)方法是什么

這篇文章主要講解了“C++中內(nèi)存池的原理及實(shí)現(xiàn)方法是什么”，文中的講解內(nèi)容簡(jiǎn)單清晰，易于學(xué)習(xí)與理解，下面請(qǐng)大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“C++中內(nèi)存池的原理及實(shí)現(xiàn)方法是什么”吧！

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

C++程序默認(rèn)的內(nèi)存管理（new，delete，malloc，free）會(huì)頻繁地在堆上分配和釋放內(nèi)存，導(dǎo)致性能的損失，產(chǎn)生大量的內(nèi)存碎片，降低內(nèi)存的利用率。默認(rèn)的內(nèi)存管理因?yàn)楸辉O(shè)計(jì)的比較通用，所以在性能上并不能做到極致。

因此，很多時(shí)候需要根據(jù)業(yè)務(wù)需求設(shè)計(jì)專用內(nèi)存管理器，便于針對(duì)特定數(shù)據(jù)結(jié)構(gòu)和使用場(chǎng)合的內(nèi)存管理，比如：內(nèi)存池。

內(nèi)存池原理

內(nèi)存池的思想是，在真正使用內(nèi)存之前，預(yù)先申請(qǐng)分配一定數(shù)量、大小預(yù)設(shè)的內(nèi)存塊留作備用。當(dāng)有新的內(nèi)存需求時(shí)，就從內(nèi)存池中分出一部分內(nèi)存塊，若內(nèi)存塊不夠再繼續(xù)申請(qǐng)新的內(nèi)存，當(dāng)內(nèi)存釋放后就回歸到內(nèi)存塊留作后續(xù)的復(fù)用，使得內(nèi)存使用效率得到提升，一般也不會(huì)產(chǎn)生不可控制的內(nèi)存碎片。

內(nèi)存池設(shè)計(jì)

算法原理：

1.預(yù)申請(qǐng)一個(gè)內(nèi)存區(qū)chunk，將內(nèi)存中按照對(duì)象大小劃分成多個(gè)內(nèi)存塊block

2.維持一個(gè)空閑內(nèi)存塊鏈表，通過指針相連，標(biāo)記頭指針為第一個(gè)空閑塊

3.每次新申請(qǐng)一個(gè)對(duì)象的空間，則將該內(nèi)存塊從空閑鏈表中去除，更新空閑鏈表頭指針

4.每次釋放一個(gè)對(duì)象的空間，則重新將該內(nèi)存塊加到空閑鏈表頭

5.如果一個(gè)內(nèi)存區(qū)占滿了，則新開辟一個(gè)內(nèi)存區(qū)，維持一個(gè)內(nèi)存區(qū)的鏈表，同指針相連，頭指針指向最新的內(nèi)存區(qū)，新的內(nèi)存塊從該區(qū)內(nèi)重新劃分和申請(qǐng)

如圖所示：

內(nèi)存池實(shí)現(xiàn)

memory_pool.hpp

#ifndef _MEMORY_POOL_H_
#define _MEMORY_POOL_H_

#include <stdint.h>
#include <mutex>

template<size_t BlockSize, size_t BlockNum = 10>
class MemoryPool
{
public:
	MemoryPool()
	{
		std::lock_guard<std::mutex> lk(mtx); // avoid race condition

		// init empty memory pointer
		free_block_head = NULL;
		mem_chunk_head = NULL;
	}

	~MemoryPool()
	{
		std::lock_guard<std::mutex> lk(mtx); // avoid race condition

		// destruct automatically
		MemChunk* p;
		while (mem_chunk_head)
		{
			p = mem_chunk_head->next;
			delete mem_chunk_head;
			mem_chunk_head = p;
		}
	}

	void* allocate()
	{
		std::lock_guard<std::mutex> lk(mtx); // avoid race condition

		// allocate one object memory

		// if no free block in current chunk, should create new chunk
		if (!free_block_head)
		{
			// malloc mem chunk
			MemChunk* new_chunk = new MemChunk;
			new_chunk->next = NULL;

			// set this chunk's first block as free block head
			free_block_head = &(new_chunk->blocks[0]);

			// link the new chunk's all blocks
			for (int i = 1; i < BlockNum; i++)
				new_chunk->blocks[i - 1].next = &(new_chunk->blocks[i]);
			new_chunk->blocks[BlockNum - 1].next = NULL; // final block next is NULL
			
			if (!mem_chunk_head)
				mem_chunk_head = new_chunk;
			else
			{
				// add new chunk to chunk list
				mem_chunk_head->next = new_chunk;
				mem_chunk_head = new_chunk;
			}
		}

		// allocate the current free block to the object
		void* object_block = free_block_head;
		free_block_head = free_block_head->next; 

		return object_block;
	}

	void* allocate(size_t size)
	{
		std::lock_guard<std::mutex> lk(array_mtx); // avoid race condition for continuous memory

		// calculate objects num
		int n = size / BlockSize;

		// allocate n objects in continuous memory
		
		// FIXME: make sure n > 0
		void* p = allocate();

		for (int i = 1; i < n; i++)
			allocate();

		return p;
	}

	void deallocate(void* p)
	{
		std::lock_guard<std::mutex> lk(mtx); // avoid race condition

		// free object memory
		FreeBlock* block = static_cast<FreeBlock*>(p);
		block->next = free_block_head; // insert the free block to head
		free_block_head = block;
	}

private:
	// free node block, every block size exactly can contain one object
	struct FreeBlock
	{
		unsigned char data[BlockSize];
		FreeBlock* next;
	};

	FreeBlock* free_block_head;

	// memory chunk, every chunk contains blocks number with fixed BlockNum
	struct MemChunk
	{
		FreeBlock blocks[BlockNum];
		MemChunk* next;
	};

	MemChunk* mem_chunk_head;

	// thread safe related
	std::mutex mtx;
	std::mutex array_mtx;
};

#endif // !_MEMORY_POOL_H_

main.cpp

#include <iostream>
#include "memory_pool.hpp"

class MyObject
{
public:
	MyObject(int x): data(x)
	{
		//std::cout << "contruct object" << std::endl;
	}

	~MyObject()
	{
		//std::cout << "destruct object" << std::endl;
	}

	int data;

	// override new and delete to use memory pool
	void* operator new(size_t size);
	void operator delete(void* p);
	void* operator new[](size_t size);
	void operator delete[](void* p);
};

// define memory pool with block size as class size
MemoryPool<sizeof(MyObject), 3> gMemPool;


void* MyObject::operator new(size_t size)
{
	//std::cout << "new object space" << std::endl;
	return gMemPool.allocate();
}

void MyObject::operator delete(void* p)
{
	//std::cout << "free object space" << std::endl;
	gMemPool.deallocate(p);
}

void* MyObject::operator new[](size_t size)
{
	// TODO: not supported continuous memoery pool for now
	//return gMemPool.allocate(size);
	return NULL;
}
void MyObject::operator delete[](void* p)
{
	// TODO: not supported continuous memoery pool for now
	//gMemPool.deallocate(p);
}

int main(int argc, char* argv[])
{
	MyObject* p1 = new MyObject(1);
	std::cout << "p1 " << p1 << " " << p1->data<< std::endl;

	MyObject* p2 = new MyObject(2);
	std::cout << "p2 " << p2 << " " << p2->data << std::endl;
	delete p2;

	MyObject* p3 = new MyObject(3);
	std::cout << "p3 " << p3 << " " << p3->data << std::endl;

	MyObject* p4 = new MyObject(4);
	std::cout << "p4 " << p4 << " " << p4->data << std::endl;

	MyObject* p5 = new MyObject(5);
	std::cout << "p5 " << p5 << " " << p5->data << std::endl;

	MyObject* p6 = new MyObject(6);
	std::cout << "p6 " << p6 << " " << p6->data << std::endl;

	delete p1;
	delete p2;
	//delete p3;
	delete p4;
	delete p5;
	delete p6;

	getchar();
	return 0;
}

運(yùn)行結(jié)果

p1 00000174BEDE0440 1
p2 00000174BEDE0450 2
p3 00000174BEDE0450 3
p4 00000174BEDE0460 4
p5 00000174BEDD5310 5
p6 00000174BEDD5320 6

可以看到內(nèi)存地址是連續(xù)，并且回收一個(gè)節(jié)點(diǎn)后，依然有序地開辟內(nèi)存
對(duì)象先開辟內(nèi)存再構(gòu)造，先析構(gòu)再釋放內(nèi)存

注意

• 在內(nèi)存分配和釋放的環(huán)節(jié)需要加鎖來保證線程安全

• 還沒有實(shí)現(xiàn)對(duì)象數(shù)組的分配和釋放

感謝各位的閱讀，以上就是“C++中內(nèi)存池的原理及實(shí)現(xiàn)方法是什么”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對(duì)C++中內(nèi)存池的原理及實(shí)現(xiàn)方法是什么這一問題有了更深刻的體會(huì)，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是億速云，小編將為大家推送更多相關(guān)知識(shí)點(diǎn)的文章，歡迎關(guān)注！