之前研究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:326087275@qq.com
*/
#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();
}