STL容器 内存释放

在一个项目中,需要在服务端保存玩家的录像回放数据,采用vector/map容器暂存了下发的消息数据,等待游戏结束后就将其写入文件,然后用clear清除掉这块缓存。

游戏上线了之后,发现其占用的内存一直上升,搜寻日志后发现,每局结束后回放占用的空间并没有释放掉,随着房间一直保留。也就是假设一共1000个房间,每个房间都有玩家游戏过后,就会有一千份回放空间没释放。

瞬 · 间 · 爆 · 炸

普遍说法是vector的clear并没有真正的释放内存,仅仅只是调用了元素的析构函数,然后调整了vector内部存取的位置。实际可以根据以下代码来观察:

#include
using namespace std;

struct TestClass
{
	TestClass(){
		m_value=3;
		puts("OK1");
	}
	
	TestClass(int value){
		m_value = value;
		puts("OK2");
	}
	
	TestClass(const TestClass &tmp){
		this->m_value = tmp.m_value;
		puts("OK3");
	}
	
	~TestClass()
	{
		printf("free TestClass , m_value = %d\n",m_value);
	}
	
	int m_value;
};

int main()
{
	TestClass testTmp(15);
	{
		vector vctTest;
		vctTest.push_back(testTmp);
		puts("PUSH OVER");
		vctTest.clear();
		puts("CLEAR OVER");
		printf("capacity = %d\n",vctTest.capacity());
		printf("test value beyond of limits: %d\n",vctTest[0].m_value);
		printf("test value beyond of limits: %d\n",vctTest[1].m_value);
	}
	puts("TEST OVER");
	
    return 0;
}

其输出的结果是

STL容器 内存释放_第1张图片

大致顺序为:

1.调用了带参构造函数,testTmp初始化完成。(输出OK2)

2.在vctTest容器的push_back时,调用拷贝构造函数新生成了一个对象,将其压入vector。(输出OK3)

3.在vctTest容器的clear中,对其中的元素调用了析构函数。(输出free TestClass , XXXX)

4.在clear完之后仍然在内存越界的边缘试探:(输出test value beyond of limits: XXXX)

5.出了定义域范围,释放vector所占空间。(输出TEST OVER)

6.main函数结束,对testTemp调用析构函数,并释放空间。(输出free TestClass , XXXX)

从上可以观察出:clear时,析构函数的确是调用了,而vector的真实大小capacity仍然是1。

而对于vector来说:其内存结构是整段连续的,每当大小不够时,就重新申请一块更大的空间,并将原数据复制过去,最后释放原空间。而这块更大的空间大小,根据vector自身策略而定,避免频繁申请内存并且复制数据,导致耗时大量增加。自然,为了减少clear之后再次扩容的消耗,所以vector选择不释放这块内存,留待之后重复利用。如果真正想要释放其内存,vector也提供了对应的方法。

然后又到了"网上普遍做法"环节:

1.用swap函数交换一个空vector来达到真正释放内存的目的。

//vctTest.swap(vector()); 
vector().swap(vctTest); 

注释掉的那种在一般情况下会报错,因为C++11不允许将临时变量赋给非const左值引用。(但VS2015可以)

具体解释请看Virtual_Func博主的这篇文章。

交换完之后,等出了定义域范围,临时变量就会被释放掉。

2.在clear完之后用shrink_to_fit函数对vector进行大小重调。

vctTest.shrink_to_fit();

不过需要C++11的支持。按照文档的说明,只是请求释放内存,标准库并不保证退换内存。

最终采用的是第一种方案,测试了一下内存的消耗确实稳定了,游戏结束后相关内存会释放掉,不会一直处于上涨的状态。


然鹅,事情并没有结束。因为运行一段时间后,发现内存虽然没有一直涨,但也保持在了一个比较高的消耗上。观察了一段时间的内存占用,发现每次游戏开始内存上涨,但游戏结束后并没有全部释放。反复N次之后,内存占用上升到一定值不再增涨,但也几乎看不出波动。于是推测应该是内存被什么东西缓存导致的。

一番查找后,发现原因在于之前所说的swap操作对map容器并没有完全起作用。通过小程序测试,往map中塞了40MB的数据后,再进行释放,其仍然占用了10MB的内存空间。这里的释放,是指用swap操作,或者是已运行到临时变量map的定义域之外。两种释放最终结果都是一样的,均有内存空间未被释放。(当然,不同机器不同情况下未释放内存比例可能不同,但应该都存在未释放的)

再联系网上的解释:STL map 内存释放

STL容器 内存释放_第2张图片

我的结论是map容器会根据策略留下一定比例的内存留待之后使用,且这块内存是无法通过swap或者析构map来释放的。而在之后的测试中,也发现在释放旧map后仍占用10MB的情况下,再去向新map中塞小于10MB的数据时,其并不会再去申请新的内存空间,而是直接使用了这10MB空间(无论新旧两个map是否同一结构,内存都是可以重复利用的)。

目前来说,暂时还未找到释放的方法,先考虑调整不用map结构,或者是调整map中存储的元素结构,缩小其内存占用。

(不过上面这位网友的做法说不定是一个途径。。?)

另外有一个发现是,即使是vector,如果是嵌套结构(即vector < vector >这种结构),对其进行swap操作也是无法释放其全部内存占用的,无论是直接整个vector swap,或者遍历vector内部对其子vector逐个swap后再将总vector进行swap,都是一样的结果。

测试用代码:

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#define MAXLEN 3072

// 定义数据流结构 
struct MsgInfo
{
	char message[MAXLEN];
	MsgInfo() {} 
};

// 桌子结构 
struct Table
{
	map m_mapInitXY;
	vector< vector > m_vtInitMsg;
	
	// 通过swap释放内存 
	void Clear()
	{
		map().swap(m_mapInitXY);
		for (int i = 0; i < m_vtInitMsg.size(); i++)
		{
			vector().swap(m_vtInitMsg[i]);
		}
		vector< vector >().swap(m_vtInitMsg);
	}
};

int main()
{
	srand(GetTickCount());
	map m_tableused;
	vector m_tableList;
	vector m_tableMsgCount;
	// 一共测试消息条数 
	int circleTimes = 10000000;
	// 当前桌子使用数 
	int tableCount = 0;
	// 结束标志 
	int XYEnd = 333;
	// 修改持续次数 
	int changeTimes = 0;
	// 期望桌子使用数 
	int maxTableUsed = 3;
	// 桌子上限 (顺便用作其他一些上限值)
	int tableLimit = 1000;
	Table *pTables = new Table[tableLimit];
	time_t lasttime = time(NULL);
	while(circleTimes--)
	{
		// 每100000条消息可修改一次期望桌子使用数
		// changetimes代表后N次修改均使用当前值 
		if (circleTimes % 100000 == 0)
		{
			if (changeTimes == 0)
			{
				printf("cost time = %d\n", time(NULL) - lasttime);
				printf("Input MaxTableUse ChangeTimes:");
				scanf("%d %d",&maxTableUsed,&changeTimes);
				lasttime = time(NULL);
			}
			changeTimes--;
		}
		
		// 随机获取将要使用的桌子 
		int tableid = 0;
		int listpos = 0;
		if (tableCount >= maxTableUsed)
		{
			listpos = rand() % tableCount;
			tableid = m_tableList[listpos];
		}
		else
		{
			tableid = rand() % tableLimit;
		}
		
		// 新桌子 
		if (m_tableused[tableid] == false)
		{
			m_tableused[tableid] = true;
			tableCount++;
			m_tableList.push_back(tableid);
			m_tableMsgCount.push_back(0);
			listpos = m_tableList.size() - 1;
			printf("CreateTable : %d\n",m_tableList[listpos]);
		}
		else
		{
			for (int i = 0; i < m_tableList.size(); i++)
			{
				if (m_tableList[i] == tableid)
				{
					listpos = i;
				}
			}
		}
		
		// 保存数据 
		Table &tableNow = pTables[tableid];
		// 随机协议号 
		int XYID = rand() % tableLimit;
		MsgInfo infoTemp;
		if (tableNow.m_mapInitXY.find(XYID) == tableNow.m_mapInitXY.end())
		{
			tableNow.m_mapInitXY[XYID] = tableNow.m_vtInitMsg.size();
			tableNow.m_vtInitMsg.push_back(vector());
		}
		int XYPos = tableNow.m_mapInitXY[XYID];
		tableNow.m_vtInitMsg[XYPos].push_back(infoTemp);
		m_tableMsgCount[listpos]++;
		
		// 消息数达到一定值后或者遇到结束标志,清除数据 
		if (m_tableMsgCount[listpos] > tableLimit || XYID == XYEnd)
		{
			tableNow.Clear();
			printf("FreeTable : %d\n",m_tableList[listpos]);
			tableCount--;
			m_tableused[tableid] = false;
			m_tableMsgCount.erase(m_tableMsgCount.begin() + listpos);
			m_tableList.erase(m_tableList.begin() + listpos);
		}
	}
	
	puts("End!");
	getchar(); 
} 

/*
sample Input:
50 2
40 2
30 2
20 2
10 2
1 2
*/

 

 

 

 

 

 

果然还是得看看STL源码剖析啊。

你可能感兴趣的:(C++)