C、C++实现的一种智能数据管理架构

之前研究STL相关结构的时候，发现STL系列的map、list、vector等设计有以下缺陷：
1.迭代删除节点的情况下只可以删除一个节点（不包括清除所有节点的情况）；
2.在多线程情况下需要加锁或临界区等形式同步对象结构信息，这种情况属于当前大部分系统设计的短板；
3.计算机运行内存产生碎片(STL系列结构分配一个新节点需要申请一次相应长度的内存空间，当清除这个节点时，这块内存有可能过短无法再次被分配使用)，

参考图1，假如STL系列结构释放当前节点在运行内存中的地址为0x0005-0x0007，并且0x0008内存地址已经被使用，如果这块内存长度过短不能够被再次分配使用，即为内存碎片。

针对上述这些情况，我做了一些猜想并进行证实，设计如下：
1.使用仿照系统内存分配方式构建内存池，完全由内存池管理所有的描述信息及内存分配；
2.使用红黑树平衡分配的节点，达到内存顺序分配(遍历)、随机分配(遍历)的高效率；
3.创建管理层维护数据节点的申请、删除等工作；
4.用户层可以存储任意结构数据，可以使用迭代顺序访问存储的数据，或随机访问存储的结构；

根据上面的设计思路，数据管理架构设计了四层：
1.最底层(第一层)是内存管理层，内存池的实现；
2.偏中层(第二层)是结构管理层，红黑树结构的上下交互实现；
3.中层(第三层)是数据管理层，提供内存分配的结构，以及内存等待区域与内存回收区域的实现；
4.上层(第四层)是用户接口层，提供用户使用结构，其中包括从内存池中分配内存空间、迭代器查询及删除、添加节点，保存任意格式的数据。

下面关于四层的详细描述：
1.内存管理层(内存池)：
https://blog.csdn.net/a29562268/article/details/82846305

2.结构管理层(红黑树结构)：
https://blog.csdn.net/a29562268/article/details/80809344
在这篇文章的基础上红黑树做了一下变动：
2.1.红黑树可以通过分配新的数据存入结构或者通过内存地址(使用内存地址作为红黑树的遍历Key)存入结构;
2.2.黑红树的维护节点也是由内存池分配；
2.3.红黑树提供调试参数，用来查看当前的树结构；
红黑树在本架构里起上下文的作用，维护了内存池分配管理和节点的遍历操作管理；

3.数据管理层：
维护内存等待区域与内存回收区域：
3.1.通过红黑树(上下文作用)进行内存分配供用户层使用；
3.2.当用户删除节点时，首先把节点放入内存等待区域(这么做的初衷是达到数据同步效果，经测试windows和linux系统必须同步化数据才能达到不越界访问)；
3.3.当等待区域内有节点超时后，放入内存回收区域，由红黑树(上下文作用)进行节点回收和红黑树的维护节点回收；
3.4.内存等待区域与内存回收区域采用线程的方式启动执行，如果当前区域内(内存等待区域或内存回收区域)没有节点，将挂起线程，等到区域内有新节点时再次启动执行；

4.用户接口层：
任何类型数据的存储(可以是自定义类)，仿照STL迭代器形式的数据节点遍历操作：
4.1.采用链表形式管理当前所有分配的节点以及申请的内存空间(可以调用申请内存函数，申请一块连续的内存使用)；
4.2.定义重载函数，可以多种形式进行存储节点(直接使用=赋值，或者List形式赋值，调用宏自定义结构赋值)；
4.3.编写迭代器，拥有遍历插入、删除等功能；

下面贴上相关代码：

1.内存管理层(内存池)：

/**
*李坤昱
*QQ：[email protected]
*/

#include "stdafx.h"
#include "LMemoryPool.h"

Lm_MemoryPool::Lm_MemoryPool(unsigned long AllocSize):m_Memory(0),m_MemoryEnd(0),
	m_nInitPoolSize(AllocSize),m_nCompareMini(1),m_nCount(0),
	m_nPoolSize(MEMPOOLSIZE),m_bRun(true)
{
	memset(m_LastError,0,sizeof(m_LastError));
}

Lm_MemoryPool::~Lm_MemoryPool()
{
	m_bRun = false;
	Sleep(200);
	Lm_MemPoolFree();
}

bool Lm_MemoryPool::Lm_SetComPareMemMini(int nMini)
{
	if (1 >= nMini)
	{
		return false;
	}
	m_nCompareMini = nMini;
	return true;
}

//设置单个内存池大小
bool Lm_MemoryPool::Lm_SetPoolSize(unsigned long nSize)
{
	if (nSize < MEMPOOLMINI)
		return false;
	m_nPoolSize = nSize;
	return true;
}

char *Lm_MemoryPool::Lm_GetLastError()
{
	return m_LastError;
}

bool Lm_MemoryPool::WriteLastError(const char *data)
{
	if (0 == data)
		return false;
	memset(m_LastError,0,sizeof(m_LastError));
	memcpy(m_LastError,data,sizeof(data));
	return true;
}
//初始化内存池
/*首先创建内存池，内存池起始地址为内存池管理表链表节点的地址加1个字节(比如第一个内存池的起始地址加1个字节为10字节，
 前10字节为第一内存池的链表信息，从10字节开始一直到内存池末尾地址为数据空间地址，所有内存池都将以这种形式存储)*/
/*这种储存方式有以下优点：1.只需要管理内存池就可以保证数据的完整与安全；2.不需要关心链表节点的分配与释放；
 3.避免链接节点释放造成的内存碎片*/
bool Lm_MemoryPool::InitMemPool(unsigned long AllocSize)
{
	//构建池子
	if (0 < AllocSize)
	{
		//多分配出内存池结构描述表内存和1个数据链表节点，这样可以保证一次分配出超出内存池大小的内存
		char *Mem = (char *)malloc(AllocSize + sizeof(MemoryStore) + 1 + sizeof(MemList) + 1);
		if (0 == Mem)
			return false;

		if (0 == m_Memory)
		{
			m_Memory = (PMemoryStore)Mem;
			m_Memory->Init();
		}
		m_Memory->StartAddress = (unsigned long)Mem;
		m_Memory->EndAddress = (m_Memory->StartAddress + AllocSize + m_Memory->MemoryStoreSize + sizeof(MemList) + 1);
		m_Memory->MemVolumeDose = (AllocSize + m_Memory->MemoryStoreSize + sizeof(MemList) + 1);
	}
	else
	{
		char *Mem = (char *)malloc(m_nPoolSize + sizeof(MemoryStore) + 1 + sizeof(MemList) + 1);
		if (0 == Mem)
			return false;

		if (0 == m_Memory)
		{
			m_Memory = (PMemoryStore)Mem;
			m_Memory->Init();
		}
		m_Memory->StartAddress = (unsigned long)Mem;
		m_Memory->EndAddress = (m_Memory->StartAddress + m_nPoolSize + m_Memory->MemoryStoreSize + sizeof(MemList) + 1);
		m_Memory->MemVolumeDose = (m_nPoolSize + m_Memory->MemoryStoreSize + sizeof(MemList) + 1);
	}

 	if (0 == m_Memory)
 		return false;

	m_Memory->Count = 1;
	m_Memory->CurrentUsageAmount = m_Memory->MemoryStoreSize;
	//数据存储起始地址
	m_Memory->StartDataAddress = (m_Memory->StartAddress + m_Memory->MemoryStoreSize);
	//内存池剩余容量
	m_Memory->SurplusVolumeDose = (m_Memory->MemVolumeDose - m_Memory->MemoryStoreSize);
	
	//分配内存失败
	if (0 ==  m_Memory->StartAddress)
	{
		WriteLastError("this MemoryAlloc is Not Valid");
		return false;
	}
	m_MemoryEnd = m_Memory;
	//记录当前内存池信息
	m_PoolCal.PoolTotal += m_Memory->MemVolumeDose;
	++m_PoolCal.PoolAmount;
	m_PoolCal.PoolUsage += m_Memory->CurrentUsageAmount;
	return true; 
}

//创建下一个内存池
bool Lm_MemoryPool::CreateNextMemPool(unsigned long AllocSize)
{
	PMemoryStore memoryPool = GetPoolHead();
	if (m_bRun && 0 == memoryPool)
	{
		InitMemPool(((AllocSize + m_nCompareMini >= m_nPoolSize) ? (AllocSize + m_nCompareMini) : m_nPoolSize));
		return true;
	}
	while (m_bRun && memoryPool && 0 != memoryPool->Next)
		memoryPool = memoryPool->Next;

	//构建池子
	if (0 < AllocSize)
	{
		//多分配出内存池结构描述表内存和1个数据链表节点，这样可以保证一次分配出超出内存池大小的内存
		char *Mem = (char *)malloc(AllocSize + sizeof(MemoryStore) + 1 + sizeof(MemList) + 1);
		if (0 == Mem)
			return false;
		if (!m_bRun)
		{
			delete Mem;
			return false;
		}
			

		memoryPool->Next = (PMemoryStore)Mem;
		memoryPool->Next->Init();
		memoryPool->Next->MemVolumeDose = (AllocSize + memoryPool->Next->MemoryStoreSize + sizeof(MemList) + 1);

		memoryPool->Next->StartAddress = (unsigned long)Mem;
		memoryPool->Next->EndAddress = (memoryPool->Next->StartAddress + AllocSize + memoryPool->Next->MemoryStoreSize + sizeof(MemList) + 1);
	}
	else
	{
		char *Mem = (char *)malloc(m_nPoolSize + sizeof(MemoryStore) + 1 + sizeof(MemList) + 1);
		if (0 == Mem)
			return false;

		memoryPool->Next = (PMemoryStore)Mem;
		memoryPool->Next->Init();
		memoryPool->Next->MemVolumeDose = (m_nPoolSize + memoryPool->Next->MemoryStoreSize + sizeof(MemList) + 1);

		memoryPool->Next->StartAddress = (unsigned long)Mem;
		memoryPool->Next->EndAddress = (memoryPool->Next->StartAddress + m_nPoolSize + memoryPool->Next->MemoryStoreSize + sizeof(MemList) + 1);
	}
	if (0 == memoryPool->Next)
		return false;

	memoryPool->Next->Count = (memoryPool->Count + 1);
	memoryPool->Next->CurrentUsageAmount = memoryPool->Next->MemoryStoreSize;
	//数据存储起始地址
	memoryPool->Next->StartDataAddress = (memoryPool->Next->StartAddress + memoryPool->Next->MemoryStoreSize);
	//内存池剩余容量
	memoryPool->Next->SurplusVolumeDose = (memoryPool->Next->MemVolumeDose - memoryPool->Next->MemoryStoreSize);
	//分配内存失败
	if (0 ==  memoryPool->Next->StartAddress)
	{
		WriteLastError("this MemoryAlloc is Not Valid");
		return false;
	}
	m_MemoryEnd = memoryPool->Next;
	m_MemoryEnd->Prev = memoryPool;
	//记录当前内存池信息
	m_PoolCal.PoolTotal += m_MemoryEnd->MemVolumeDose;
	++m_PoolCal.PoolAmount;
	m_PoolCal.PoolUsage += m_MemoryEnd->CurrentUsageAmount;
	return true; 
}

void *Lm_MemoryPool::Lm_MemAlloc(unsigned long nSize)
{
	return GetPoolMem(nSize);
}

//获取首个内存池信息
PMemoryStore Lm_MemoryPool::GetPoolHead()
{
	return m_Memory;
}
//获取最后一个内存池信息
PMemoryStore Lm_MemoryPool::GetPoolEnd()
{
	return m_MemoryEnd;
}
//从所有内存池中取出未使用的内存地址
void *Lm_MemoryPool::GetPoolMem(unsigned long nSize)
{
	PMemoryStore pool = GetPoolHead();
	
	while (m_bRun && pool)
	{
		char *pData = (char *)GetAPoolofMem(pool,nSize);
		if (0 != pData)
			return (void *)pData;
		pool = pool->Next;
	}	
	//如果没有创建内存池或者所有的池子都遍历了还是没有合适内存，那么创建一个新的池子
	if ((nSize + m_nCompareMini)  > m_nPoolSize)
		CreateNextMemPool(nSize + m_nCompareMini);
	else
		CreateNextMemPool(m_nPoolSize);

		char *pData = (char *)GetAPoolofMem(m_MemoryEnd,nSize);
		return (void *)pData;
}

//从一块内存池中获取数据
void *Lm_MemoryPool::GetAPoolofMem(PMemoryStore obj,unsigned long nSize)
{
	if (!m_bRun || 0 == obj || 0 >= obj->SurplusVolumeDose || nSize >= obj->SurplusVolumeDose)
	{
		return 0;
	}
		//如果达到查询的条件 开始遍历对应编号的内存池 ，为了最大利用内存选择从头开始遍历，如果没有数据插入到最后
		PMemList listData = obj->GetHeadList();
		while (m_bRun && listData && (0 != listData->Next))
		{

			//如果节点中保存的内存使用量大于或等于需要分配的内存，那么使用这块内存
			if ((nSize + m_nCompareMini  <= listData->CurrentUsgeAmount) && (0 == listData->bValid))
			{
				PMemList PList = RevampMemUsgeAmount(obj,listData,nSize);
				PList->bValid = 1;
				return (void *)PList->StartAddress;
			}
			listData = listData->Next;
		}
	//创建新的节点保存分配内存
	return CreateNextMem(obj,nSize,1);
}

//修改指定内存块当前使用量
PMemList Lm_MemoryPool::RevampMemUsgeAmount(PMemoryStore pool,PMemList list,unsigned long nSize)
{
	PMemList pList = list;
	if (0 != pool)
	{
		unsigned long nLen = 0;
		pList = MemAllocOfList(list,nSize,nLen);
		pool->CurrentUsageAmount += nLen;
		pool->SurplusVolumeDose = (pool->MemVolumeDose - pool->CurrentUsageAmount);
		m_PoolCal.PoolUsage += nLen;
	}

	return pList;
}

//回收废弃的内存
void Lm_MemoryPool::recycleMemUsgeAmount(PMemoryStore pool,unsigned long nSize)
{
	if (0 != pool)
	{
		pool->CurrentUsageAmount -= nSize;
		pool->SurplusVolumeDose = (pool->MemVolumeDose - pool->CurrentUsageAmount);
		m_PoolCal.PoolUsage -= nSize;
	}
}

//数据链表分配内存，如果当前数据链表节点内存多出需要分配的一部分，那么内存分配后，再创建一个新的节点管理多余的当前节点内存
PMemList Lm_MemoryPool::MemAllocOfList(PMemList list,unsigned long nSize,unsigned long & nLen)
{
	//如果当前节点的内存空间大于需要分配内存加上节点描述内存加5个字节，那么创建一个新的节点
	if (m_bRun && list->CurrentUsgeAmount >= (nSize + sizeof(MemList) + 5))
	{
		PMemList Nextlist = list->Next;
		list->Next = (PMemList)(list->StartAddress + nSize + 2);
		list->Next->nodeInfo.StartAddress = (list->StartAddress + nSize + 2);
		list->Next->nodeInfo.CurrentUsgeAmount = (sizeof(MemList) + 1);
		list->Next->StartAddress = (list->Next->nodeInfo.StartAddress + list->Next->nodeInfo.CurrentUsgeAmount);
		list->Next->EndAddress = list->EndAddress;
		list->Next->CurrentUsgeAmount = (list->CurrentUsgeAmount - list->Next->nodeInfo.CurrentUsgeAmount - nSize - 2);

		list->Next->Next = Nextlist;
		list->Next->Next->Prev = list->Next;
		list->Next->Prev = list;

		list->CurrentUsgeAmount = (nSize + 1);
		list->EndAddress = (list->StartAddress + nSize + 1);
		nLen = (list->CurrentUsgeAmount + sizeof(MemList) + 2);
	}
	else
		nLen = list->CurrentUsgeAmount;
	//分配干净的内存
	memset((void *)list->StartAddress,0,list->CurrentUsgeAmount);
	return list;
}

//创建新的节点以及分配内存
void *Lm_MemoryPool::CreateNextMem(PMemoryStore obj,unsigned long nSize,bool bValid)
{
	PMemList list = obj->GetEndList();
	list = CreateMemList(obj,list,nSize);
	if (0 == list)
		return 0;

	list->StartAddress = (obj->StartDataAddress + obj->StartDataOffsetAddress);
	//多分配一个字节用来防止内存越界
	list->EndAddress = (list->StartAddress + nSize + 1);
	list->CurrentUsgeAmount = (nSize + 1);
	list->bValid = bValid;
	obj->CurrentUsageAmount += list->CurrentUsgeAmount;
	obj->SurplusVolumeDose -= list->CurrentUsgeAmount;
	obj->StartDataOffsetAddress += list->CurrentUsgeAmount;
	obj->pMemEnd = list;
	obj->pMemEnd->Next = 0;

	m_PoolCal.PoolUsage += list->CurrentUsgeAmount;
	//分配出一段干净的内存 上层方便使用
	memset((void *)list->StartAddress,0,list->CurrentUsgeAmount);
	return (void *)list->StartAddress;
}

PMemList Lm_MemoryPool::CreateMemList(PMemoryStore pool,PMemList list,int nSize)
{
	if (!m_bRun)
		return 0;

	if (0 == list)
	{
		list = (PMemList)(pool->StartDataAddress + pool->StartDataOffsetAddress);
		if (0 == list)
			return 0;

		list->Init();
		if (0 == list)
			return 0;

		list->nodeInfo.StartAddress = (pool->StartDataAddress + pool->StartDataOffsetAddress);
		list->nodeInfo.CurrentUsgeAmount = (sizeof(MemList) + 1);
		pool->pMemHead = list;

		pool->CurrentUsageAmount += list->nodeInfo.CurrentUsgeAmount;
		pool->SurplusVolumeDose -= list->nodeInfo.CurrentUsgeAmount;
		//当前数据偏移地址
		pool->StartDataOffsetAddress += list->nodeInfo.CurrentUsgeAmount;

		m_PoolCal.PoolUsage += list->nodeInfo.CurrentUsgeAmount;
		return list;
	}

	list->Next = (PMemList)(pool->StartDataAddress + pool->StartDataOffsetAddress);
	if (0 == list)
		return 0;

	list->Next->Init();
	if (0 == list->Next)
		return 0;

	list->Next->nodeInfo.StartAddress = (pool->StartDataAddress + pool->StartDataOffsetAddress);
	list->Next->nodeInfo.CurrentUsgeAmount = (sizeof(MemList) + 1);
	list->Next->Prev = list;

	pool->CurrentUsageAmount += list->Next->nodeInfo.CurrentUsgeAmount;
	pool->SurplusVolumeDose -= list->Next->nodeInfo.CurrentUsgeAmount;
	//当前数据偏移地址
	pool->StartDataOffsetAddress += list->Next->nodeInfo.CurrentUsgeAmount;

	m_PoolCal.PoolUsage += list->Next->nodeInfo.CurrentUsgeAmount;
	return list->Next;
}

//内存释放
bool Lm_MemoryPool::Lm_MemFree(void * ptr)
{
	//根据分配的地址在内存池中匹配，匹配到后 修改结构数据后，等待再次使用
	PMemoryStore pool = GetPoolHead();
	while (m_bRun && pool)
	{
		PMemList list = pool->GetHeadList();
		while (m_bRun && list)
		{
			//如果链表中其中一节数据与需要释放的地址相同 ，而且这段数据属于使用中，属于这块内存
			if ((list->StartAddress == (unsigned long)ptr) && (1 == list->bValid))
			{
				recycleMemUsgeAmount(pool,list->CurrentUsgeAmount);
				//回收的时候不需要初始化内存，因为再次使用的时候会进行初始化
				list->bValid = 0;
				ptr = 0;
				//判断链表中上一个节点与下一个节点是否为未使用的内存(把连续未使用的内存放在一起)
				if (pool)
					ContinuousMemory(list,pool);

				return true;
			}
			list = list->Next;
		}
		pool = pool->Next;
	}
	return false;
}

//判断链表中上一个节点与下一个节点是否为未使用的内存(把连续未使用的内存放在一起)
void Lm_MemoryPool::ContinuousMemory(PMemList list,PMemoryStore pool)
{
	PMemList pList = mergePrivMemory(list,pool);
	pList = mergeNextMemory(pList,pool);
	GiveBackMemory(pList,pool);
	//内存池使用率低于百分之四十的情况下释放未使用的内存池
	FreeNeedlessPool();
}

//合并当前链表中与上一个链表中未使用的内存
PMemList Lm_MemoryPool::mergePrivMemory(PMemList list,PMemoryStore pool)
{
	int nNum = 0;
	while (m_bRun && list->Prev && !list->Prev->bValid)
	{
		list->Prev->CurrentUsgeAmount += (list->nodeInfo.CurrentUsgeAmount + list->CurrentUsgeAmount);
		list->Prev->EndAddress = list->EndAddress;
		//如果是第一次合并内存，只需要减去链表描述结构大小即可
		if (0 == nNum)
		{
			pool->CurrentUsageAmount -= list->nodeInfo.CurrentUsgeAmount;
			pool->SurplusVolumeDose += list->nodeInfo.CurrentUsgeAmount;

			m_PoolCal.PoolUsage -= list->nodeInfo.CurrentUsgeAmount;
		}
		else
		{
			pool->CurrentUsageAmount -= (list->nodeInfo.CurrentUsgeAmount + list->CurrentUsgeAmount);
			pool->SurplusVolumeDose += (list->nodeInfo.CurrentUsgeAmount + list->CurrentUsgeAmount);

			m_PoolCal.PoolUsage -= (list->nodeInfo.CurrentUsgeAmount + list->CurrentUsgeAmount);
		}
		++nNum;

		if (list->Next)
		{
			list->Prev->Next = list->Next;
			list->Next->Prev = list->Prev;
		}
		else
		{
			list->Prev->Next = 0;
		}

		list = list->Prev;
		//如果上一个节点存在 而且是有效节点 或者 上一个节点不存在，直接返回本次执行结果
		if ((list->Prev  && list->Prev->bValid) || !list->Prev)
			return list;
	}
	return list;
}

//合并当前链表中与下一个链表中未使用的内存
PMemList Lm_MemoryPool::mergeNextMemory(PMemList list,PMemoryStore pool)
{
	while (m_bRun && list->Next && !list->Next->bValid)
	{
		//两块连续未使用的内存合并，并且去掉后面未使用内存的链表节点(一起放入合并的内存中)
		list->CurrentUsgeAmount += (list->Next->nodeInfo.CurrentUsgeAmount + list->Next->CurrentUsgeAmount);
		list->EndAddress = list->Next->EndAddress;
		//计算内存池当前使用量和可用量
		pool->CurrentUsageAmount -= (list->Next->nodeInfo.CurrentUsgeAmount + list->Next->CurrentUsgeAmount);
		pool->SurplusVolumeDose += (list->Next->nodeInfo.CurrentUsgeAmount + list->Next->CurrentUsgeAmount);

		m_PoolCal.PoolUsage -= (list->Next->nodeInfo.CurrentUsgeAmount + list->Next->CurrentUsgeAmount);

		if (list->Next->Next)
		{
			list->Next->Next->Prev = list;
			list->Next = list->Next->Next;
		}
		else
			list->Next = 0;
		//如果下一个节点存在 而且是有效节点 或者 下一个节点不存在，直接返回本次执行结果
		if ((list->Next  && list->Next->bValid) || !list->Next)
			return list;
	}
	return list;
}

//如果当前数据链表节点后面没有分配的节点，那么把这部分内存信息描述擦除，由内存池分配使用
void Lm_MemoryPool::GiveBackMemory(PMemList list,PMemoryStore pool)
{
	if (m_bRun && list && !list->Next)
	{
		pool->CurrentUsageAmount -= list->nodeInfo.CurrentUsgeAmount;
		pool->SurplusVolumeDose += list->nodeInfo.CurrentUsgeAmount;
		pool->StartDataOffsetAddress = (list->nodeInfo.StartAddress - pool->StartDataAddress);

		m_PoolCal.PoolUsage -= list->nodeInfo.CurrentUsgeAmount;

		if (list->Prev)
			list->Prev->Next = 0;
		else //数据链表已经没有节点了，完全由内存池分配使用
			pool->pMemHead = pool->pMemEnd = 0;
	}
}

//释放内存池 ，这个不需要手动释放 ，类对象销毁前会进行释放
bool Lm_MemoryPool::Lm_MemPoolFree()
{
	PMemoryStore memPool = GetPoolHead();
	while (0 != memPool)
	{
		PMemoryStore next =  memPool->Next;
		MemPoolFree_(memPool->Count);
		memPool = next;
	}
	return true;
}

//释放指定编号内存池
bool Lm_MemoryPool::MemPoolFree_(int nCount)
{
	PMemoryStore memPool = GetPoolHead();
	while (memPool->Count != nCount)
		memPool = memPool->Next;

	if (0 == memPool)
		return false;

	PMemoryStore Prev = 0,next = 0;
	if (0 != memPool->Prev)
		Prev = memPool->Prev;
	if (0 != memPool->Next)
		next = memPool->Next;

	//修改内存池使用率信息
	m_PoolCal.PoolTotal -= memPool->MemVolumeDose;
	m_PoolCal.PoolUsage -= memPool->CurrentUsageAmount;
	--m_PoolCal.PoolAmount;

	delete memPool;
	memPool = 0;
	if (0 != Prev)
		Prev->Next = next;
	else
		m_Memory = next;
	if (0 != next)
		next->Prev = Prev;
	else
		m_MemoryEnd = m_Memory;
	return true;
}

//内存池使用率低于百分之四十的情况下释放未使用的内存池
void Lm_MemoryPool::FreeNeedlessPool()
{
	ReRun:
	if (40 >= ((double)m_PoolCal.PoolUsage / (double)m_PoolCal.PoolTotal * 100) && 2 <= m_PoolCal.PoolAmount)
	{
		//找到未使用的内存池进行释放
		PMemoryStore memPool = GetPoolHead();
		while (0 != memPool)
		{
			if (0 == memPool->StartDataOffsetAddress)
			{
				MemPoolFree_(memPool->Count);
				//释放内存池后，继续检查内存使用率是否大于百分之四十
				goto ReRun;
			}
			else
				memPool = memPool->Next;
		}
	}
}

2.结构管理层(红黑树结构)：

#include "stdafx.h"
#include "LRb_tree.h"

Lr_Rb_tree::Lr_Rb_tree():m_NodeInfo(0)
{
#ifdef DEBUG
	m_bLr = true;
#endif
}

Lr_Rb_tree::~Lr_Rb_tree()
{
	if (m_NodeInfo)
		delete m_NodeInfo;
	//All_Delete_Rb_tree_node();
}

bool Lr_Rb_tree::CreateHead(unsigned long nCount)
{
	return Init_node(nCount);
}

//初始化
bool Lr_Rb_tree::Init_node(unsigned long nCount)
{
	if (_S_red != m_head._M_color && _S_black != m_head._M_color)
	{
		m_head._M_left = &m_head;
		m_head._M_right = &m_head;
		m_head._M_parent = 0;
		m_head._M_color = _S_red;
		m_head.data.nCount = nCount;
		m_head.data.Val = (void*)nCount;
		m_node_count = 0;
		return true;
	}
	return false;
}

//创建节点 
Lr_Rb_tree_node_base* Lr_Rb_tree::Create_Rb_tree_node(unsigned long val)
{
	Lr_Rb_tree_node_base* ptr = (Lr_Rb_tree_node_base*)m_pool.Lm_MemAlloc(sizeof(Lr_Rb_tree_node_base));
	if (0 == ptr)
		return 0;

	memset(ptr,0,sizeof(ptr));
	ptr->_M_color = _S_red;
	ptr->data.nCount = val;
	ptr->data.Val = (void*)val;

#ifdef DEBUG
	//测试使用
	static unsigned long nCount = 0;
	if (m_bLr)
	{
		nCount = 0;
		m_bLr = false;
	}
	ptr->data.nLrCount = ++nCount;
#endif
	return ptr;
}



//添加树数据
unsigned long Lr_Rb_tree::Lr_insert(void* val)
{
	unsigned long pdata = WriteData((char*)val);
	//判断是否有头节点 如果没有创建头节点
	if (CreateHead(pdata))
		return pdata;
	return Lr_P_Insert(pdata);
}

//添加树节点
unsigned long Lr_Rb_tree::Lr_insert(unsigned long nSize)
{
	unsigned long pdata = GetMemory(nSize);
	//判断是否有头节点 如果没有创建头节点
	if (CreateHead(pdata))
		return pdata;
	return Lr_P_Insert(pdata);
}

//添加树节点以及绑定数据
unsigned long Lr_Rb_tree::Lr_P_Insert(unsigned long nCount)
{
	if (0 == nCount)
		return 0;

	Lr_Rb_tree_Ptr x = Begin();
	Lr_Rb_tree_Ptr y = End();
	Lr_Rb_tree_Ptr pbound;
	//首先检查val是否与之前插入过的数据有重复
	if (0 == (pbound = Lr_M_lower_bound(x,y,nCount)))
	{
		m_pool.Lm_MemFree((void*)nCount);
		return 0;
	}

	//增加数节点以及插入数据
	if (!Lr_M_insert_unique_(pbound,nCount))
	{
		m_pool.Lm_MemFree((void*)nCount);
		return 0;
	}

	return nCount;
}

//从内存池中分配内存并使用
unsigned long Lr_Rb_tree::WriteData(char *data)
{
	if (0 == data)
		return 0;
	void* pdata = m_pool.Lm_MemAlloc(strlen(data));
	memcpy(pdata,data,strlen(data));
	return (unsigned long)pdata;
}

//从内存池中获取指定大小
unsigned long Lr_Rb_tree::GetMemory(unsigned long nSize)
{
	if (0 >= nSize)
		return 0;
	void* pdata = m_pool.Lm_MemAlloc(nSize);
	return (unsigned long)pdata;
}

//
bool Lr_Rb_tree::Lr_M_insert_unique_(Lr_Rb_tree_Ptr position, const unsigned long & __v)
{

	// end()
	if (position == End())
	{
		if (size() > 0 && 1 == compare_less(Right(), __v))
			return Lr_M_insert_(0, Right(), __v);
		else
			return Lr_M_insert_unique(__v);
	}
	else if (-1 == compare_less(position, __v))
	{
		if (position == Left()) // begin()
			return Lr_M_insert_(Left(), Left(), __v);
		else if (position->_M_parent)
		{
			if (position->_M_parent->_M_right == 0)
				return Lr_M_insert_(0, position->_M_parent, __v);
			else
				return Lr_M_insert_(position, position, __v);
		}
		else
			return Lr_M_insert_unique(__v);
	}
	else if (1 == compare_less(position, __v))
	{
		// ... then try after.
		if (position == Right())
			return Lr_M_insert_(0, Right(), __v);

		else if (1 == compare_less(position->_M_right, __v))
		{
			if (Right(position->_M_right) == 0)
				return Lr_M_insert_(0, position->_M_right, __v);
			else
				return Lr_M_insert_(position->_M_right, position->_M_right, __v);
		}
		else
			return Lr_M_insert_unique(__v);
	}
		return false;
}

//
bool Lr_Rb_tree::Lr_M_insert_unique(const unsigned long& __v)
{
	Lr_Rb_tree_Ptr __x = Begin();
	Lr_Rb_tree_Ptr __y = End();
	bool __comp = true;
	while (__x != 0)
	{
		__y = __x;
		__comp = compare_less(__x,__v);
		__x = __comp ? Left(__x) : Right(__x);
	}
	Lr_Rb_tree_Ptr __j = __y;
	if (__comp)
	{
		if (__y == Begin())
			return Lr_M_insert_(__x, __y, __v);
		else
			__j = __j->_M_left;
	}
	//if (1 == compare_less(__j,__v))
		return Lr_M_insert_(__x, __y, __v);
	//return false;
}

//
long long Lr_Rb_tree::size()
{
	return m_node_count;
}

//
bool Lr_Rb_tree::Lr_M_insert_(Lr_Rb_tree_Ptr x,Lr_Rb_tree_Ptr y,unsigned long val)
{
	bool __insert_left = (x != 0 || y == End()
		
		|| -1 == compare_less(y,val));

	Lr_Rb_tree_Ptr z = Create_Rb_tree_node(val);
	if (0 == z)
		return z;

	Lr_Rb_tree_insert_and_rebalance(__insert_left, z,
		y,  this->m_head);
	++m_node_count;
	return true;
}

//返回需要插入节点的位置
Lr_Rb_tree_node_base* Lr_Rb_tree::Lr_M_lower_bound(Lr_Rb_tree_Ptr x,Lr_Rb_tree_Ptr y,unsigned long val)
{
	while (x != 0)
	{
		int nless = compare_less(x, val);
		if (-1 == nless)
			y = x, x = Left(x);
		else if (1 == nless)
			x = Right(x);
		else//如果相等，这条数据不再插入，直接返回
			return 0;
	}
	
	return y;
}

//返回查找到的节点位置，如果没有返回空
Lr_Rb_tree_node_base* Lr_Rb_tree::Lr_FindNode(unsigned long val)
{
	//临时保存需要插入的节点位置
	Lr_Rb_tree_Ptr x = Begin();
	while (x != 0)
	{
		int nless = compare_less(x, val);
		if (-1 == nless)
			x = Left(x);
		else if (1 == nless)
			x = Right(x);
		else if (-2 == nless)
			return 0;
		else//如果相等，返回这条数据
			return x;
	}
	return 0;
}

//
int Lr_Rb_tree::compare_less(Lr_Rb_tree_Ptr x,unsigned long val)
{
	if (0 == x)
		return -2;

	if (x->data.nCount < val)
	{
		return 1;
	}
	else if (x->data.nCount > val)
	{
		return -1;
	}
	return 0;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Begin()
{
	return m_head._M_parent;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::End()
{
	return &m_head;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Left()
{
	return m_head._M_left;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Left(Lr_Rb_tree_Ptr ptr)
{
	return ptr->_M_left;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Right()
{
	return m_head._M_right;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Right(Lr_Rb_tree_Ptr ptr)
{
	return ptr->_M_right;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Minimum(Lr_Rb_tree_Ptr ptr)
{
	while (ptr->_M_left != 0) ptr = ptr->_M_left;
	return ptr;
}

//
Lr_Rb_tree_node_base* Lr_Rb_tree::Maximum(Lr_Rb_tree_Ptr ptr)
{
	while (ptr->_M_right != 0) 
		ptr = ptr->_M_right;
	return ptr;
}

void Lr_Rb_tree::Lr_Rb_tree_insert_and_rebalance(const bool __insert_left,
	Lr_Rb_tree_node_base* __x,
	Lr_Rb_tree_node_base* __p,
	Lr_Rb_tree_node_base& __header)//红黑树结构内核实现
{
	Lr_Rb_tree_node_base **rootptrptr = &__header._M_parent;

	__x->_M_parent = __p;
	__x->_M_left = 0;
	__x->_M_right = 0;
	__x->_M_color = _S_red;

	if(__insert_left){
		__p->_M_left = __x;
		if(__p == &__header){
			__header._M_parent = __x;
			__header._M_right = __x;
		}else if( __p == __header._M_left )
			__header._M_left = __x;
	}else{
		__p->_M_right = __x;
		if(__p == __header._M_right)
			__header._M_right = __x;
	}

	while( __x != *rootptrptr && __x->_M_parent->_M_color==_S_red ){
		Lr_Rb_tree_node_base* const xpp = __x->_M_parent->_M_parent;
		if(__x->_M_parent == xpp->_M_left){
			Lr_Rb_tree_node_base* const y = xpp->_M_right;
			if(y && y->_M_color == _S_red){
				__x->_M_parent->_M_color = _S_black;
				y->_M_color = _S_black;
				xpp->_M_color = _S_red;
				__x = xpp;
			}else{
				if( __x==__x->_M_parent->_M_right){
					__x = __x->_M_parent;

					_Rb_tree_rotate_left(__x,*rootptrptr);
				}
				__x->_M_parent->_M_color = _S_black;
				xpp->_M_color = _S_red;
				_Rb_tree_rotate_right(xpp,*rootptrptr);
			}
		}else{
			Lr_Rb_tree_node_base* const y = xpp->_M_left;
			if(y && y->_M_color == _S_red){
				__x->_M_parent->_M_color = _S_black;
				y->_M_color = _S_black;
				xpp->_M_color = _S_red;
				__x = xpp;
			}else{
				if(__x == __x->_M_parent->_M_left){
					__x = __x->_M_parent;
					_Rb_tree_rotate_right(__x,*rootptrptr);
				}
				__x->_M_parent->_M_color = _S_black;
				xpp->_M_color = _S_red;
				_Rb_tree_rotate_left(xpp,*rootptrptr);
			}
		}
	}
	(*rootptrptr)->_M_color = _S_black;
	return ;
}


//删除树节点
bool Lr_Rb_tree::Lr_earse(unsigned long val)
{
	if (0 >= size())
		return false;

	Lr_Rb_tree_Ptr ptr = Lr_FindNode(val);
	if (0 == ptr)
		return false;
	Lr_Rb_tree_rebalance_for_erase(ptr,*Begin(),End()->_M_left,End()->_M_right);
	Delete_Rb_tree_node(ptr);
	ptr = 0;
	--m_node_count;
	return true;
}

//删除节点
void Lr_Rb_tree::Delete_Rb_tree_node(Lr_Rb_tree_Ptr & ptr)
{
	//删除数据
	m_pool.Lm_MemFree(ptr->data.Val);
	if (Begin()->data.nCount != ptr->data.nCount)
		//删除描述结构
		m_pool.Lm_MemFree(ptr);
	else
		m_head._M_color = Lr_Rb_tree_color(-1);
}

//删除所有节点，不平衡树结构
void Lr_Rb_tree::Lr_M_erase(Lr_Rb_tree_Ptr ptr)
{
	while (ptr != 0)
	{
		Lr_M_erase(Right(ptr));
		Lr_Rb_tree_Ptr left = Left(ptr);
		Delete_Rb_tree_node(ptr);
		ptr = left;
	}
}

//删除所有节点
void Lr_Rb_tree::All_Delete_Rb_tree_node()
{
	Lr_M_erase(Begin());
	m_node_count = 0;
	m_head._M_color = Lr_Rb_tree_color(-1);
	m_head._M_parent = 0;
	m_head._M_left = &m_head;
	m_head._M_right = &m_head;
}

Lr_Rb_tree_node_base* Lr_Rb_tree::Lr_Rb_tree_rebalance_for_erase(Lr_Rb_tree_node_base* __z,
	Lr_Rb_tree_node_base& __root,
	Lr_Rb_tree_node_base*& __leftmost,
	Lr_Rb_tree_node_base*& __rightmost)
{
	Lr_Rb_tree_node_base* __y = __z;
	Lr_Rb_tree_node_base* __x = 0;
	Lr_Rb_tree_node_base* __x_parent = 0;
	Lr_Rb_tree_node_base* __root_ = &__root;
	if (__y->_M_left == 0)     // __z has at most one non-null child. y == z.
		__x = __y->_M_right;     // __x might be null.
	else
		if (__y->_M_right == 0)  // __z has exactly one non-null child. y == z.
			__x = __y->_M_left;    // __x is not null.
		else {                   // __z has two non-null children.  Set __y to
			__y = __y->_M_right;   //   __z's successor.  __x might be null.
			while (__y->_M_left != 0)
				__y = __y->_M_left;
			__x = __y->_M_right;
		}
		if (__y != __z) {          // relink y in place of z.  y is z's successor
			__z->_M_left->_M_parent = __y; 
			__y->_M_left = __z->_M_left;
			if (__y != __z->_M_right) {
				__x_parent = __y->_M_parent;
				if (__x) __x->_M_parent = __y->_M_parent;
				__y->_M_parent->_M_left = __x;      // __y must be a child of _M_left
				__y->_M_right = __z->_M_right;
				__z->_M_right->_M_parent = __y;
			}
			else
				__x_parent = __y;  
			if (__root_ == __z)
				__root_ = __y;
			else if (__z->_M_parent->_M_left == __z)
				__z->_M_parent->_M_left = __y;
			else 
				__z->_M_parent->_M_right = __y;
			__y->_M_parent = __z->_M_parent;
			//swap(__y->_M_color, __z->_M_color);
			__y = __z;
			// __y now points to node to be actually deleted
		}
		else {                        // __y == __z
			__x_parent = __y->_M_parent;
			if (__x) __x->_M_parent = __y->_M_parent;   
			if (__root_ == __z)
				__root_ = __x;
			else 
				if (__z->_M_parent->_M_left == __z)
					__z->_M_parent->_M_left = __x;
				else
					__z->_M_parent->_M_right = __x;
			if (__leftmost == __z) 
				if (__z->_M_right == 0)        // __z->_M_left must be null also
					__leftmost = __z->_M_parent;
			// makes __leftmost == _M_header if __z == __root
				else
					__leftmost = Minimum(__x);
			if (__rightmost == __z)  
				if (__z->_M_left == 0)         // __z->_M_right must be null also
					__rightmost = __z->_M_parent;  
			// makes __rightmost == _M_header if __z == __root
				else                      // __x == __z->_M_left
					__rightmost = Maximum(__x);
		}
		if (__y->_M_color != _S_red) { 
			while (__x != __root_ && (__x == 0 || __x->_M_color == _S_black))
				if (__x == __x_parent->_M_left) {
					Lr_Rb_tree_node_base* __w = __x_parent->_M_right;
					if (__w->_M_color == _S_red) {
						__w->_M_color = _S_black;
						__x_parent->_M_color = _S_red;
						_Rb_tree_rotate_left(__x_parent, __root_);
						__w = __x_parent->_M_right;
					}
					if ((__w->_M_left == 0 || 
						__w->_M_left->_M_color == _S_black) &&
						(__w->_M_right == 0 || 
						__w->_M_right->_M_color == _S_black)) {
							__w->_M_color = _S_red;
							__x = __x_parent;
							__x_parent = __x_parent->_M_parent;
					} else {
						if (__w->_M_right == 0 || 
							__w->_M_right->_M_color == _S_black) {
								if (__w->_M_left) __w->_M_left->_M_color = _S_black;
								__w->_M_color = _S_red;
								_Rb_tree_rotate_right(__w, __root_);
								__w = __x_parent->_M_right;
						}
						__w->_M_color = __x_parent->_M_color;
						__x_parent->_M_color = _S_black;
						if (__w->_M_right) __w->_M_right->_M_color = _S_black;
						_Rb_tree_rotate_left(__x_parent, __root_);
						break;
					}
				} else {                  // same as above, with _M_right <-> _M_left.
					Lr_Rb_tree_node_base* __w = __x_parent->_M_left;
					if (__w->_M_color == _S_red) {
						__w->_M_color = _S_black;
						__x_parent->_M_color = _S_red;
						_Rb_tree_rotate_right(__x_parent, __root_);
						__w = __x_parent->_M_left;
					}
					if (__w && (__w->_M_right == 0 || 
						__w->_M_right->_M_color == _S_black) &&
						(__w->_M_left == 0 || 
						__w->_M_left->_M_color == _S_black)) {
							__w->_M_color = _S_red;
							__x = __x_parent;
							__x_parent = __x_parent->_M_parent;
					} else {
						if (__w && (__w->_M_left == 0 || 
							__w->_M_left->_M_color == _S_black)) {
								if (__w->_M_right) __w->_M_right->_M_color = _S_black;
								__w->_M_color = _S_red;
								_Rb_tree_rotate_left(__w, __root_);
								__w = __x_parent->_M_left;
						}
						__w->_M_color = __x_parent->_M_color;
						__x_parent->_M_color = _S_black;
						if (__w->_M_left) __w->_M_left->_M_color = _S_black;
						_Rb_tree_rotate_right(__x_parent, __root_);
						break;
					}
				}
				if (__x) __x->_M_color = _S_black;
		}
		return __y;
}

void Lr_Rb_tree::_Rb_tree_rotate_left(Lr_Rb_tree_node_base* __x, Lr_Rb_tree_node_base*& __root)//节点左旋转
{
	Lr_Rb_tree_node_base* __y = __x->_M_right;
	__x->_M_right = __y->_M_left;
	if (__y->_M_left !=0)
		__y->_M_left->_M_parent = __x;
	__y->_M_parent = __x->_M_parent;

	if (__x == __root)
		__root = __y;
	else if (__x == __x->_M_parent->_M_left)
		__x->_M_parent->_M_left = __y;
	else
		__x->_M_parent->_M_right = __y;
	__y->_M_left = __x;
	__x->_M_parent = __y;
}

void Lr_Rb_tree::_Rb_tree_rotate_right(Lr_Rb_tree_node_base* __x, Lr_Rb_tree_node_base*& __root)//节点右旋转
{
	Lr_Rb_tree_node_base* __y = __x->_M_left;
	__x->_M_left = __y->_M_right;
	if (__y->_M_right != 0)
		__y->_M_right->_M_parent = __x;
	__y->_M_parent = __x->_M_parent;

	if (__x == __root)
		__root = __y;
	else if (__x == __x->_M_parent->_M_right)
		__x->_M_parent->_M_right = __y;
	else
		__x->_M_parent->_M_left = __y;
	__y->_M_right = __x;
	__x->_M_parent = __y;
}

//显示节点信息
char * Lr_Rb_tree::ShowNodeInfo()
{
	if (0 == m_node_count)
		return 0;
	if (0 != m_NodeInfo)
	{
		delete m_NodeInfo;
		m_NodeInfo = new char[m_node_count * 50];
		memset(m_NodeInfo,0,sizeof(m_NodeInfo));
	}
	else
	{
		m_NodeInfo = new char[m_node_count * 50];
		memset(m_NodeInfo,0,sizeof(m_NodeInfo));
	}
	int noffset = 0;
	unsigned long nVal = 0;
	return GetNodeInfo(WriteRootInfo(m_NodeInfo,m_head._M_parent,noffset,nVal),m_head._M_parent,noffset,nVal,-1);
}

//写入root信息
char * Lr_Rb_tree::WriteRootInfo(char *nodeInfo,Lr_Rb_tree_node_base * node,int & noffset,unsigned long & nVal)
{
	if (0 == nodeInfo)
		return 0;
	if (node)
	{
#ifdef DEBUG
		sprintf(nodeInfo,"The root node is %d\r\n",node->data.nLrCount);
#else
		sprintf(nodeInfo,"The root node is %d\r\n",node->data.nCount);
#endif
		noffset = strlen(nodeInfo);
		nVal = node->data.nCount;
		*(nodeInfo + nVal) = 0;
	}
	return nodeInfo;
}

//节点信息写入字符串
char * Lr_Rb_tree::GetNodeInfo(char *nodeInfo,Lr_Rb_tree_node_base * node,int & noffset,unsigned long nVal,int left)
{
	if (0 == nodeInfo)
		return 0;
	if (node)
	{
		if (-1 != left)
			WriteNodeInfo(nodeInfo,node,noffset,nVal,left);
#ifdef DEBUG
		if (node->_M_left)
			GetNodeInfo(nodeInfo,node->_M_left,noffset,/*node->_val*/node->data.nLrCount,1);
		if (node->_M_right)
			GetNodeInfo(nodeInfo,node->_M_right,noffset,node->data.nLrCount,0);
#else
		if (node->_M_left)
			GetNodeInfo(nodeInfo,node->_M_left,noffset,/*node->_val*/node->data.nCount,1);
		if (node->_M_right)
			GetNodeInfo(nodeInfo,node->_M_right,noffset,node->data.nCount,0);
#endif
	}
	return nodeInfo;
}

//写入节点数据
char * Lr_Rb_tree::WriteNodeInfo(char *nodeInfo,Lr_Rb_tree_node_base * node,int & noffset,unsigned long nVal,bool left)
{
	char TempData[100] = {0};
#ifdef DEBUG
	if (_S_red == node->_M_color)	
		sprintf(TempData,"%d is the red %s node of %d\r\n",/*node->_val*/node->data.nLrCount,(left ? "left" : "right"),nVal);
	else if (_S_black == node->_M_color)
		sprintf(TempData,"%d is the black %s node of %d\r\n",node->data.nLrCount,(left ? "left" : "right"),nVal);
#else
	if (_S_red == node->_M_color)	
		sprintf(TempData,"%d is the red %s node of %d\r\n",/*node->_val*/node->data.nCount,(left ? "left" : "right"),nVal);
	else if (_S_black == node->_M_color)
		sprintf(TempData,"%d is the black %s node of %d\r\n",node->data.nCount,(left ? "left" : "right"),nVal);
#endif
		int nLen = strlen(TempData);
		memcpy(nodeInfo + noffset,TempData,nLen);
		noffset += nLen;
		*(nodeInfo + noffset) = 0;
		return nodeInfo;
}

3.数据管理层：

#include "stdafx.h"
#include "Lmangement.h"

Lmangement::Lmangement():m_WaitThread(0),m_RecycleThread(0),m_WaitHead(0),m_WaitEnd(0),m_RecycleHead(0)
	,m_RecycleEnd(0)
	,m_bRunWaitArea(false)
	,m_bRunRecycleArea(false)
{

}

Lmangement::~Lmangement()
{
	if (m_WaitThread)
		CloseHandle(m_WaitThread),m_WaitThread = 0;
	if (m_RecycleThread)
		CloseHandle(m_RecycleThread),m_RecycleThread = 0;
}

//放入到等待或删除区域
bool Lmangement::Lm_WaitArea(PNode node)
{
	if (100 > GetTickCount() - node->ntime)
	{
		WaitAddNode(node);
		return Run_WaitArea();
	}

	return RecycleInValidNode(node);
}

//直接回收不使用的内存
bool Lmangement::Lm_Recycle(PNode node)
{
	return RecycleInValidNode(node);
}

//运行等待区域
bool Lmangement::Run_WaitArea()
{
	if (!GetWaitHandle())
		return (m_WaitThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)WaitAreaThread,this,CREATE_SUSPENDED,NULL));
	else if (GetWaitHandle() && !IsWaitAreaRun())
	{
		if (1 <= ResumeThread(GetWaitHandle()))
			SetWaitArea(true);
		else 
			return false;
	}
		
	return true;
}

//运行回收区域
bool Lmangement::Run_RecycleArea()
{
	if (!GetRecycleHandle())
		return (m_RecycleThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)RecycleAreaThread,this,CREATE_SUSPENDED,NULL));
	else if (GetRecycleHandle() && !IsRecycleAreaRun())
	{
		DWORD nval;
		if (1 <= (nval = ResumeThread(GetRecycleHandle())))
			SetRecycleArea(true);
		else
			return false;
	}

	return true;
}

//等待区域放入节点
void Lmangement::WaitAddNode(PNode node)
{
	if (IsWaitArea())
		InsertWaitHead(node);
	else
		InsertWaitEnd(node);
}

//回收区域放入节点
void Lmangement::RecycleNode(PNode node)
{
	if (IsRecycleArea())
		InsertRecycleHead(node);
	else
		InsertWaitEnd(node);
	//启动回收线程
	Run_RecycleArea();
}

//检查等待区域是否为空
bool Lmangement::IsWaitArea()
{
	return (m_WaitHead == 0);
}

//检查回收区域是否为空
bool Lmangement::IsRecycleArea()
{
	return (m_RecycleHead == 0);
}

//等待区域头位置增加节点
void Lmangement::InsertWaitHead(PNode node)
{
	m_WaitHead = m_WaitEnd = node;
	m_WaitHead->Prev = 0;
}

//等待区域尾部位置增加节点
void Lmangement::InsertWaitEnd(PNode node)
{
	m_WaitEnd = node;
	m_WaitEnd->Next = 0;
}

//等待区域头位置增加节点
void Lmangement::InsertRecycleHead(PNode node)
{
	m_RecycleHead = m_RecycleEnd = node;
	m_RecycleHead->Prev = 0;
}

//等待区域尾部位置增加节点
void Lmangement::InsertRecycleEnd(PNode node)
{
	m_RecycleEnd = node;
	m_RecycleEnd->Next = 0;
}

//获取等待节点，true 头节点,false end 末尾节点
PNode Lmangement::GetWaitNode(bool bHead)
{
	if (bHead)
		return m_WaitHead;
	else
		return m_WaitEnd;
}

//获取回收节点，true 头节点,false end 末尾节点
PNode Lmangement::GetRecycleNode(bool bHead)
{
	if (bHead)
		return m_RecycleHead;
	else
		return m_RecycleEnd;
}

//获取当前等待区域状态是否正在运行
bool Lmangement::IsWaitAreaRun()
{
	return m_bRunWaitArea;
}

//获取当前回收区域状态是否正在运行
bool Lmangement::IsRecycleAreaRun()
{
	return m_bRunRecycleArea;
}

//设置当前等待区域状态
void Lmangement::SetWaitArea(bool bRun)
{
	m_bRunWaitArea = bRun;
}

//设置当前回收区域状态
void Lmangement::SetRecycleArea(bool bRun)
{
	m_bRunRecycleArea = bRun;
}

DWORD CALLBACK Lmangement::WaitAreaThread(void* _this)
{
	Lmangement * ment = (Lmangement *)_this;
ReRun:
	PNode node = ment->GetWaitNode(true);
	while ((node || (node = ment->GetWaitNode(true))) && ment->IsWaitAreaRun() && ment->GetWaitHandle())
	{
		unsigned long nCurrent = GetTickCount();
		PNode nextnode = node->Next;
		if (DeleteNodeTime <= nCurrent - node->ntime)
		{
			ment->RemoveWaitNode(node); 
			//放入回收区域
			ment->RecycleNode(node);
		}
		node = nextnode;
	}
	
	ment->SetWaitArea(false);
ReSuspend:
	//如果释放了句柄 直接退出线程
	if (!ment->GetWaitHandle())
		return 0;
	//挂起线程，有任务时，自动开始运行
	if ( -1 == SuspendThread(ment->GetWaitHandle()))
		goto ReSuspend;

	goto ReRun;
	return 0;
}

//回收区域线程
DWORD CALLBACK Lmangement::RecycleAreaThread(void* _this)
{
	Lmangement * ment = (Lmangement *)_this;
ReRun:
	PNode node = ment->GetRecycleNode(true);
	while ((node || (node = ment->GetRecycleNode(true))) && ment->IsRecycleAreaRun() && ment->GetRecycleHandle())
	{
		PNode nextnode = node->Next;
		ment->RecycleInValidNode(node);
		//节点和数据占用内存放回内存池
		ment->RemoveRecycleNode(node);
		node = nextnode;
	}

	ment->SetRecycleArea(false);
ReSuspend:
	//如果释放了句柄 直接退出线程
	if (!ment->GetRecycleHandle())
		return 0;
	//挂起线程，有任务时，自动开始运行
	DWORD nval;
	if (-1 == (nval = SuspendThread(ment->GetRecycleHandle())))
		goto ReSuspend;

	goto ReRun;
	return 0;
}

//回收无效节点函数
bool Lmangement::RecycleInValidNode(PNode node)
{
	if (!Lr_earse((unsigned long)node->Data))
		return false;
	return Lr_earse((unsigned long)node);
}

//从等待区域内去掉当前节点
void Lmangement::RemoveWaitNode(PNode node)
{
	if (0 == node)
		return;

	if (0 == node->Prev && 0 != node->Next)
	{
		InsertWaitHead(node->Next);
	}
	else if (0 != node->Prev && 0 != node->Next)
	{
		MergeNode(node->Prev,node->Next);
	}
	else if (0 != node->Prev && 0 == node->Next)
	{
		SetNextNode(node->Prev,0);
		InsertWaitEnd(node->Prev);
	}
	else//最后一种情况只有当前一个节点
	{
		InitWaitListNode();
	}
}

//从回收区域内去掉当前节点
void Lmangement::RemoveRecycleNode(PNode node)
{
	if (0 == node)
		return;

	if (0 == node->Prev && 0 != node->Next)
	{
		InsertRecycleHead(node->Next);
	}
	else if (0 != node->Prev && 0 != node->Next)
	{
		MergeNode(node->Prev,node->Next);
	}
	else if (0 != node->Prev && 0 == node->Next)
	{
		SetNextNode(node->Prev,0);
		InsertRecycleEnd(node->Prev);
	}
	else//最后一种情况只有当前一个节点
	{
		InitRecycleListNode();
	}
}


//两段断开的链表，合并成一条链表
bool Lmangement::MergeNode(PNode Prev,PNode next)
{
	if (0 == Prev || 0 == next)
		return false;

	SetNextNode(Prev,next);
	SetPrevNode(next,Prev);
	return true;
}


//设置上一个节点
void Lmangement::SetPrevNode(PNode DstNode,PNode SrcNode)
{
	DstNode->Prev = SrcNode;
}

//设置下一个节点
void Lmangement::SetNextNode(PNode DstNode,PNode SrcNode)
{
	DstNode->Next = SrcNode;
}

//初始化等待区域链表节点
void Lmangement::InitWaitListNode()
{
	m_WaitEnd = m_WaitHead = 0;
}

//初始化等待区域链表节点
void Lmangement::InitRecycleListNode()
{
	m_RecycleEnd = m_RecycleHead = 0;
}

//获取等待区域线程句柄
HANDLE Lmangement::GetWaitHandle()
{
	return m_WaitThread;
}

//获取等待区域线程句柄
HANDLE Lmangement::GetRecycleHandle()
{
	return m_RecycleThread;
}

4.用户接口层：

#include "stdafx.h"
#include "LData.h"

LData::LData():m_nNodeTotal(0),m_bRun(true)
{
	InitListNode();
}


LData::~LData()
{
	m_bRun = false;
}

//初始化链表节点
bool LData::InitNode()
{
	if (0 == m_HeadNode)
	{
		int nNodeLen = sizeof(Node);
		m_HeadNode = (PNode)allocMem(nNodeLen);
		if (0 == m_HeadNode)
			return false;

		m_HeadNode->InitNode();
		m_EndNode = m_HeadNode;
		//计算当前分配内存总量
		++m_nNodeTotal;
		return true;
	}
	
	return false;
}

//获取头节点
PNode LData::GetNodeHead()
{
	return m_HeadNode;
}

//获取尾节点
PNode LData::GetNodeEnd()
{
	return m_EndNode;
}

//分配新的头节点
PNode LData::InsertHeadNode(PNode node)
{
	m_HeadNode = node;
	m_HeadNode->Prev = 0;
	return m_HeadNode;
}

//分配新的尾节点
PNode LData::InsertEndNode(PNode node)
{
	m_EndNode = node;
	m_EndNode->Next = 0;
	return m_EndNode;
}

//分配出节点使用
PNode LData::AllocNode(bool bHead)
{
	int nLen = sizeof(Node);
	PNode node = 0;
	if (bHead && 0 != GetNodeHead())
	{
		node = GetNodeHead();
		node->Prev = (PNode)allocMem(nLen);
		if (0 == node->Prev)
			return 0;
		node->Prev->InitNode();
		
		SetNextNode(node->Prev,m_HeadNode);
		node = InsertHeadNode(node->Prev);
		//计算当前分配内存总量
		++m_nNodeTotal;
	}
	else if (!bHead && 0 != GetNodeEnd())
	{
		node = GetNodeEnd();
		node->Next = (PNode)allocMem(nLen);
		if (0 == node->Next)
			return 0;
		node->Next->InitNode();

		SetPrevNode(node->Next,m_EndNode);
		node = InsertEndNode(node->Next);
		//计算当前分配内存总量
		++m_nNodeTotal;
	}

	return node;
}

//分配一个单独的链表节点
PNode LData::AllocAloneNode()
{
	int nLen = sizeof(Node);
	PNode node = (PNode)allocMem(nLen);
	if (0 == node)
		return 0;

	node->InitNode();
	return node;
}

//分配出可以使用的节点,用来关联数据
PNode LData::UsableNode(bool bHead)
{
	if (bHead && m_bRun && m_HeadNode && type_error == m_HeadNode->Type)
		return m_HeadNode;
	else if (!bHead && m_bRun && m_EndNode && type_error == m_EndNode->Type)
		return m_EndNode;

	return AllocNode(bHead);
}

//从内存池中获取内存使用
unsigned long LData::allocMem(unsigned long nSize)
{
	return Lr_insert(nSize);
}

//获取一段连续的内存，并且已经记录在容器结构中
void* LData::Ld_GetMem(unsigned long nSize,bool bHead)
{
	if (!m_bRun)
		return 0;

	unsigned long nCount = allocMem(nSize);
	InitNode();
	PNode node = UsableNode(bHead);
	node->InitNode();
	node->Type = type_string;
	node->Data = (void*)nCount;
	return node->Data;
}



//保存重载得到的数据
PNode LData::OperList(Data_Type type,int nLen,bool bHead,bool bNew)
{
	InitNode();
	PNode node = UsableNode(bHead);
	if (0 == node)
		return 0;

	switch (type)
	{
	case type_int8:
		node->Type = type_int8;
		break;
	case type_uint8:
		node->Type = type_uint8;
		break;
	case type_int16:
		node->Type = type_int16;
		break;
	case type_uint16:
		node->Type = type_uint16;
		break;
	case type_int32:
		node->Type = type_int32;
		break;
	case type_uint32:
		node->Type = type_uint32;
		break;
	case type_int64:
		node->Type = type_int64;
		break;
	case type_uint64:
		node->Type = type_uint64;
		break;
	case type_string:
		node->Type = type_string;
		break;
	case type_obj:
		node->Type = type_obj;
		break;
	default:
		node->Type = type_error;
		break;
	}
	if (type_error == node->Type)
		return 0;

	if (bNew)
	{
		unsigned long nCount = allocMem(nLen);
		node->Data = (void*)nCount;
	}
	return node;
}

//保存重载得到的数据信息
void* LData::OperData(void* data,void* obj,Data_Type type,int nLen)
{
	if (0 == nLen)
		return 0;
	switch (type)
	{
	case type_int8:
		*(char*)data = *(char*)obj;
		break;
	case type_uint8:
		*(unsigned char*)data = *(unsigned char*)obj;
		break;
	case type_int16:
		*(short*)data = *(short*)obj;
		break;
	case type_uint16:
		*(unsigned short*)data = *(unsigned short*)obj;
		break;
	case type_int32:
		*(int*)data = *(int*)obj;
		break;
	case type_uint32:
		*(unsigned int*)data = *(unsigned int*)obj;
		break;
	case type_int64:
		*(long long*)data = *(long long*)obj;
		break;
	case type_uint64:
		*(unsigned long long*)data = *(unsigned long long*)obj;
		break;
	case type_string:
		memcpy(data,obj,nLen);
		break;
	case type_obj:
		memcpy(data,obj,nLen);
		break;
	}
	return data;
}

char LData::operator = (const char & obj)
{
	PNode node = OperList(type_int8,sizeof(char));
	if (0 == node)
		return 0;

	return (char)OperData(node->Data,(void*)&obj,type_int8);
}

unsigned char LData::operator = (const unsigned char & obj)
{
	PNode node = OperList(type_uint8,sizeof(unsigned char));
	if (0 == node)
		return 0;

	return (unsigned char)OperData(node->Data,(void*)&obj,type_uint8);
}

short LData::operator = (const short & obj)
{
	PNode node = OperList(type_int16,sizeof(short));
	if (0 == node)
		return 0;

	return (short)OperData(node->Data,(void*)&obj,type_int16);
}

unsigned short LData::operator = (const unsigned short & obj)
{
	PNode node = OperList(type_uint16,sizeof(unsigned short));
	if (0 == node)
		return 0;

	return (unsigned short)OperData(node->Data,(void*)&obj,type_uint16);
}

int LData::operator = (const int & obj)
{
	PNode node = OperList(type_int32,sizeof(int));
	if (0 == node)
		return 0;

	return (int)OperData(node->Data,(void*)&obj,type_int32);
}

unsigned int LData::operator = (const unsigned int & obj)
{
	PNode node = OperList(type_uint32,sizeof(unsigned int));
	if (0 == node)
		return 0;

	return (unsigned int)OperData(node->Data,(void*)&obj,type_uint32);
}

long long LData::operator = (const long long & obj)
{
	PNode node = OperList(type_int64,sizeof(long long));
	if (0 == node)
		return 0;

	return (long long)OperData(node->Data,(void*)&obj,type_int64);
}

unsigned long long LData::operator = (const unsigned long long & obj)
{
	PNode node = OperList(type_uint64,sizeof(unsigned long long));
	if (0 == node)
		return 0;

	return (unsigned long long)OperData(node->Data,(void*)&obj,type_uint64);
}

char* LData::operator = (const char*  obj)
{
	PNode node = OperList(type_string,strlen(obj));
	if (0 == node)
		return 0;

	return (char*)OperData(node->Data,(void*)obj,type_string,strlen(obj));
}

void* LData::InClassObj(const void* obj,int nlen)
{
	if (!m_bRun)
		return 0;

	PNode node = OperList(type_obj,nlen);
	if (0 == node)
		return 0;

	return OperData(node->Data,(void*)obj,type_obj,nlen);
}

//返回头节点
LData_iterator LData::Begin()
{
	iter.iterNode = GetNodeHead();
	return iter;
}

//返回末尾节点
LData_iterator LData::End()
{
	iter.iterNode = GetNodeEnd();
	return iter;
}

//给需要删除的结构增加删除时间
void LData::AddNodeTime(PNode node)
{
	node->ntime = GetTickCount();
}

//删除数据 放入到管理层的等待区域，等待后续处理
bool LData::Ld_erase(LData_iterator it)
{
	if (!m_bRun || 0 == it.iterNode || type_error == it.iterNode->Type)
		return false;

	AddNodeTime(it.iterNode);
	PNode node = separateNode(it.iterNode);
	if (0 == node)
		return false;
	--m_nNodeTotal;
	return Lm_WaitArea(node);
}

//需要删除的数据与链表分离
PNode LData::separateNode(PNode node)
{
	if (0 == node)
		return 0;

	if (0 == node->Prev && 0 != node->Next)
	{
		InsertHeadNode(node->Next);
		return node;
	}
	else if (0 != node->Prev && 0 != node->Next)
	{
		MergeNode(node->Prev,node->Next);
		return node;
	}
	else if (0 != node->Prev && 0 == node->Next)
	{
		SetNextNode(node->Prev,0);
		InsertEndNode(node->Prev);
		return node;
	}
	else if (0 == node->Prev && 0 == node->Next)//最后一种情况只有当前一个节点
	{
		InitListNode();
	}
	return node;
}


//初始化链表节点
void LData::InitListNode()
{
	m_EndNode = m_HeadNode = 0;
	m_nNodeTotal = 0;
}

//获取数据类型长度
int LData::GetTypeLen(Data_Type type)
{
	int nLen = 0;
	switch (type)
	{
	case type_int8:
		nLen = sizeof(char);
		break;
	case type_uint8:
		nLen = sizeof(unsigned char);
		break;
	case type_int16:
		nLen = sizeof(short);
		break;
	case type_uint16:
		nLen = sizeof(unsigned short);
		break;
	case type_int32:
		nLen = sizeof(int);
		break;
	case type_uint32:
		nLen = sizeof(unsigned int);
		break;
	case type_int64:
		nLen = sizeof(long long);
		break;
	case type_uint64:
		nLen = sizeof(unsigned long long);
		break;
	}
	return nLen;
}

//修改节点保存的数据类型
void LData::ReviseNodeType(PNode node,Data_Type type)
{
	node->Type = type;
}

//指定位置增加数据
bool LData::Ld_insert(iterator it,void *data,Data_Type type,unsigned long nLen)
{
	if (!m_bRun)
		return false;

	int nlen = (nLen > 0 ? nLen : GetTypeLen(type));
	if (0 >= nlen)
		return false;

	PNode node = AllocAloneNode();
	if (0 == node)
		return false;

	ReviseNodeType(node,type);
	unsigned long nCount = allocMem(nlen);
	node->Data = (void*)nCount;
	//计算当前分配内存总量
	++m_nNodeTotal;

	if (type_string == type || type_obj == type)
		(char*)OperData(node->Data,(void*)data,type,nlen);
	else
		(char*)OperData(node->Data,(void*)&data,type,nlen);

	return InsertNodeToList(node,it.iterNode,true);
}


//一节链表节点 嵌入到链表指定位置
bool LData::InsertNodeToList(PNode SrcNode,PNode DsrNode,bool prev)
{
	if (0 == SrcNode || 0 == DsrNode)
		return false;

	if (prev)
	{
		if (DsrNode->Prev)
		{
			SetPrevNode(SrcNode,DsrNode->Prev);
			SetNextNode(SrcNode,DsrNode);
			SetNextNode(DsrNode->Prev,SrcNode);
			SetPrevNode(DsrNode,SrcNode);
		}
		else 
		{
			SetNextNode(SrcNode,DsrNode);
			SetPrevNode(DsrNode,SrcNode);
			InsertHeadNode(SrcNode);
		}
	}
	else
	{
		if (DsrNode->Next)
		{
			SetPrevNode(SrcNode,DsrNode);
			SetNextNode(SrcNode,DsrNode->Next);
			SetPrevNode(DsrNode->Next,SrcNode);
			SetNextNode(DsrNode,SrcNode);
		}
		else
		{
			SetPrevNode(SrcNode,DsrNode);
			SetNextNode(DsrNode,SrcNode);
			InsertEndNode(SrcNode);
		}
	}
	return true;
}

//获取指定位置数据类型
Data_Type LData::Ld_GetDataType(iterator it)
{
	if (!m_bRun)
		return type_error;

	if (0 == it.iterNode)
		return type_error;

	return it.iterNode->Type;
}

//获取指定位置数据值
void* LData::Ld_GetData(iterator it)
{
	if (!m_bRun)
		return 0;

	if (0 == it.iterNode)
		return 0;

	return it.iterNode->Data;
}

//向容器结构中插入数据，主要作用是从内存池中分配的内存进行保存
bool LData::Ld_push_back(void *data,Data_Type type,bool bNew,unsigned long nSize)
{
	if (!m_bRun)
		return false;

	int nlen = (nSize > 0 ? nSize : GetTypeLen(type));
	if (0 >= nlen)
		return false;

	PNode node = OperList(type,nlen,false,bNew);
	if (0 == node)
		return false;


	if (!bNew)
		node->Data = data;
	else
	{
		if (type_string == type || type_obj == type)
			(char*)OperData(node->Data,(void*)data,type,nlen);
		else
			(char*)OperData(node->Data,(void*)&data,type,nlen);
	}

	return true;
}

//在第一位向前插入
bool LData::Ld_push_front(void *data,Data_Type type,bool bNew,unsigned long nSize)
{
	if (!m_bRun)
		return false;

	int nlen = (nSize > 0 ? nSize : GetTypeLen(type));
	if (0 >= nlen)
		return false;

	PNode node = OperList(type,nlen,true,bNew);
	if (0 == node)
		return false;

	if (!bNew)
		node->Data = data;
	else
	{
		if (type_string == type || type_obj == type)
			return (char*)OperData(node->Data,(void*)data,type,nlen);
		else
			return (char*)OperData(node->Data,(void*)&data,type,nlen);
	}

	return false;
}

//清除所有节点
void LData::Ld_clear()
{
	PNode node = GetNodeHead();
	while (m_bRun && node)
	{
		PNode next = node->Next;
		Lm_Recycle(node);
		node = next;
	}
	InitListNode();
}

数据架构下载地址！