内存池技术的应用和详细说明

最新推荐文章于 2024-06-11 15:45:51 发布
最新推荐文章于 2024-06-11 15:45:51 发布
阅读量1.6k 收藏
点赞数
分类专栏： wince开发

此文内容有误 请慎重阅读 个人认为释放内存块的部分写的有问题 无法实现功能

为了控制CE的串口反复不断的分配内存，出现内存碎片，防止出现内存泄露，于是把从MFC上学到的那个内存池简化了一下，直接用到了程序上

，虽然很简单，但是如果只要稍加二次封装，即可写出类似于MFC中通过哈希表进行内存控制访问的方法。具体的方法呢，直接上代码最清楚：

.h文件
//内存分配结构体
typedef struct __LinkList
{
 struct __LinkList *pNext;
 BYTE buf[2048];
 int len;
}LINKLIST,*PLINKLIST;

int const BUFSIZE = 10;   //分配内存块大小
class CMemoryPool
{
public:
 CMemoryPool(void);
  ~CMemoryPool(void);
public:
 void InitPars(void);
 LINKLIST* GetFreeBuf(void);         //得到空闲内存
 bool AddFreeList(LINKLIST*pLink);   //将用毕内存返回空闲链表
 bool FreeBufRelease(void);          //释放所有内存池内内存
public:
 LINKLIST* m_pLinklistHeader;        //分配内存单位的头
 LINKLIST* m_pLinkListFreeHeader;    //空闲链表内存BUF头
 int m_iPoolFreeCount;    //缓冲区内单元大小数量
 LINKLIST *m_pllink;                 //内存缓冲区分配指针
};
.cpp文件

#include "StdAfx.h"
#include "MemoryPool.h"

CMemoryPool::CMemoryPool(void)
: m_pLinklistHeader(NULL)
, m_pLinkListFreeHeader(NULL)
, m_iPoolFreeCount(0)
, m_pllink(NULL)
{
 InitPars();//初始化内存池
}

CMemoryPool::~CMemoryPool(void)
{
 FreeBufRelease();
}


void CMemoryPool::InitPars(void)
{
 //分配内存
 this->m_iPoolFreeCount = BUFSIZE;
 m_pllink = (LINKLIST*)new BYTE[sizeof(LINKLIST) * BUFSIZE];
 memset(m_pllink,0,sizeof(LINKLIST) * BUFSIZE);
 m_pllink += BUFSIZE - 1;
 this->m_pLinklistHeader = m_pllink; //指定空闲结点

 for (int num = BUFSIZE; num >= 0;num--,m_pllink--)
 {
  m_pllink->pNext = this->m_pLinkListFreeHeader;
  this->m_pLinkListFreeHeader = m_pllink;
 }
}


LINKLIST* CMemoryPool::GetFreeBuf(void)
{
 //取得内存地址
 LINKLIST* pLink = this->m_pLinkListFreeHeader;
 this->m_pLinkListFreeHeader = this->m_pLinkListFreeHeader->pNext; //摘走一个内存单元
 this->m_iPoolFreeCount--;

 if (m_iPoolFreeCount <= 0)
 {
  AfxMessageBox(_T("内存池耗尽！"));
  return NULL;
 }
 return pLink;
}


bool CMemoryPool::AddFreeList(LINKLIST*pLink)
{
 //挂到最后一个结点
 this->m_pLinklistHeader->pNext = pLink;
 pLink->pNext = NULL;
 this->m_pLinklistHeader = pLink;
 this->m_iPoolFreeCount++;

 return true;
}

 

bool CMemoryPool::FreeBufRelease(void)
{
 delete []m_pllink;
 return false;
}

这里有一个小插曲，我在定义LINKLIST这个结构体时最初struct __LinkList *pNext;在最后，结果一使用就报字节对齐的问题，按说指针也应该是一个整形数据啊，后来把它移到结构体的头上，把INT LEN移到最后，就不报了，没找到具体别的原因。

为了更容易的让大家使用和理解，我把MFC的内存池原理代码也附上，如果你想弄得更清楚，可以看王艳平老师的WINDOWS程序设计第五章，这

里向大家建一言，一定要多看书，而且一定要看好书，更要会看书，取其精华，舍其糟粕，又扯远了。

///
// _AFXPLEX_.H文件

#ifndef __AFXPLEX_H__
#define __AFXPLEX_H__

#include "_afxwin.h"

struct CPlex
{
 CPlex* pNext; // 向每个内层块中添加的额外信息，指向下一个内存块首地址的指针

 // 这里是真正的数据区，BYTE data[maxNum*elementSize];
 void* data() { return this + 1; }

 // 用于申请内存的全局函数。申请cbElement大小的空间nMax个
 static CPlex* Create(CPlex*& pHead, UINT nMax, UINT cbElement);

 // 释放以当前对象为首地址（this指针）的内存链中的所有内存
 void FreeDataChain();
};

#endif // __AFXPLEX_H__

#include "_afxplex_.h"

CPlex* CPlex::Create(CPlex*& pHead, UINT nMax, UINT cbElement)
{
 CPlex* p = (CPlex*)new BYTE[sizeof(CPlex) + nMax*cbElement];

 // 将新增加的内存块添加到链中，并将其地址做为首地址
 p->pNext = pHead;
 pHead = p;  // 以相反方向添加数据项的方式大大减化了程序设计
 return p;
}

void CPlex::FreeDataChain()
{
 // 以当前内存块的地址为首地址
 CPlex* p = this;
 // 释放链中所有内存块占用的内存
 while(p != NULL)
 {
  BYTE* pBytes = (BYTE*)p;
  CPlex* pNext = p->pNext;
  delete[] pBytes;
  p = pNext;
 }
}
注意void* data() { return this + 1; }这个技巧，呵呵，新学的可能不太明白，这里说一下，在函数CPlex* p = (CPlex*)new BYTE

[sizeof(CPlex) + nMax*cbElement];里面，我们分配了一大块连续内存区域，包括一块CPlex大小的内存+nMax*cbElement实际需要的大小内存，这样，而这一整块的类型被强制转换成了CPlex*，我们知道，指针++，会跳跃一个指针指向内容的大小的单元，举个例子，如果CHAR*P，P++会移

动一个字符，如果是INT*P，P++会移动四个字符，如此类推。所以，你明白了吧。
还有就是CPlex::FreeDataChain函数里的CPlex* p = this;然后强制转一下成BYTE*，直接释放，内存管理起来多么方便，就不用再单独的释放数据区的内存了。（可以同我的博文“结构体最后的长度为0或1数组的作用”印证来看。）

大家注意，这个内存块是逆向增加的，所以你分配的最后一个内存块恰恰是你的

this对象，明白了吧。

///
// _AFXCOLL.H文件

#ifndef __AFXCOLL_H__
#define __AFXCOLL_H__

#include "_afxwin.h"
#include "_afxplex_.h"

class CMapPtrToPtr
{
protected:
 // 关联（Association）
 struct CAssoc
 {
  CAssoc* pNext; // 指向下一个CAssoc结构
  void* key; // 键对象
  void* value; // 值对象
 };

public:
// 构造函数（Construction）
 CMapPtrToPtr(int nBlockSize = 10);

// 属性成员（Attributes）
 // 元素的个数
 int GetCount() const;
 BOOL IsEmpty() const;
 // 在映射中查找key所对应的rValue
 BOOL Lookup(void* key, void*& rValue);

// 操作（Operations）
 // 查找或者是添加key对应的value
 void*& operator[](void* key);
 // 添加一个新的（key, vaule）对
 void SetAt(void* key, void* newValue);

 // 移除一个存在的（key, ?）对
 BOOL RemoveKey(void* key);
 void RemoveAll();

 UINT GetHashTableSize() const;
 void InitHashTable(UINT nHashSize, BOOL bAllocNow = TRUE);
 UINT HashKey(void* key) const;

// 实现（Implementation）
protected:
 CAssoc** m_pHashTable;
 int m_nHashTableSize;

 struct CPlex* m_pBlocks; // 保存用CPlex::Create函数申请的内存块的首地址
 int m_nBlockSize;  // 指定每个内存块可以容纳多少个CAssoc结构
 CAssoc* m_pFreeList;  // 预留空间中没有被使用的CAssoc结构组成的链中第一个关联的指针
 int m_nCount;   // 记录了程序一共使用了多少个CAssoc结构，即关联的个数

 // 为一个新的CAssoc结构提供空间，相当于使用new操作符
 CAssoc* NewAssoc();
 // 释放一个CAssoc结构占用的空间，相当于使用delete操作符
 void FreeAssoc(CAssoc* pAssoc);
 // 寻找键key所在的关联
 CAssoc* GetAssocAt(void* key, UINT& nHash) const;
public:
 ~CMapPtrToPtr();
};

inline int CMapPtrToPtr::GetCount() const
{ return m_nCount; }
inline BOOL CMapPtrToPtr::IsEmpty() const
{ return m_nCount == 0; }
inline void CMapPtrToPtr::SetAt(void* key, void* newValue)
{ (*this)[key] = newValue; }
inline UINT CMapPtrToPtr::GetHashTableSize() const
{ return m_nHashTableSize; } 

#endif // __AFXCOLL_H__

///
// MAP_PP.CPP文件


#include "_afxcoll.h"

CMapPtrToPtr::CMapPtrToPtr(int nBlockSize)
{
 m_pHashTable = NULL;
 m_nHashTableSize = 17; // 默认大小
 m_pBlocks = NULL;
 m_nBlockSize = nBlockSize;
 m_pFreeList = NULL;
 m_nCount = 0;
}

inline UINT CMapPtrToPtr::HashKey(void* key) const
{
 UINT Value = ((UINT)(void*)(DWORD)key) >> 4;
 return Value;
}

void CMapPtrToPtr::InitHashTable(UINT nHashSize, BOOL bAllocNow)
{
 if(m_pHashTable != NULL)
 {
  // 释放计算表
  delete[] m_pHashTable;
  m_pHashTable = NULL;
 }

 if(bAllocNow)
 {
  // 为计算表申请空间
  m_pHashTable = new CAssoc*[nHashSize];
  memset(m_pHashTable, 0, sizeof(CAssoc*)*nHashSize);
 }
 m_nHashTableSize = nHashSize;
}

CMapPtrToPtr::CAssoc* CMapPtrToPtr::GetAssocAt(void* key, UINT& nHash) const
{
 // 计算包含key的项在表中的位置
 nHash = HashKey(key)%m_nHashTableSize;
 if(m_pHashTable == NULL)
  return NULL;

 // 在以m_pHashTable[nHash]为头指针的链表中查找
 CAssoc* pAssoc;
 for(pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext)
 {
  if(pAssoc->key == key)
   return pAssoc;
 }
 return NULL;
}

BOOL CMapPtrToPtr::Lookup(void* key, void*& rValue)
{
 UINT nHash;
 CAssoc* pAssoc = GetAssocAt(key, nHash);
 if(pAssoc == NULL)
  return FALSE; // 没有在映射中

 rValue = pAssoc->value;
 return TRUE;
}

void*& CMapPtrToPtr::operator [] (void* key)
{
 UINT nHash;
 CAssoc* pAssoc;
 if((pAssoc = GetAssocAt(key, nHash)) == NULL)
 {
  if(m_pHashTable == NULL)
   InitHashTable(m_nHashTableSize);

  // 既然映射中没有用户指定的项，我们就添加一个新的关联
  pAssoc = NewAssoc();
  pAssoc->key = key;

  // 将新的关联放入计算表中（放在表头，不是表尾）
  pAssoc->pNext = m_pHashTable[nHash];
  m_pHashTable[nHash] = pAssoc;
 }
 return pAssoc->value; // 返回value的引用
}

BOOL CMapPtrToPtr::RemoveKey(void* key)
{
 if(m_pHashTable == NULL) 
  return FALSE; // 表中什么也没有

 CAssoc** ppAssocPre; // 记录要删除的项的地址的变量的地址（如果存在的话，我们会改变此地址处的值）
 ppAssocPre = &m_pHashTable[HashKey(key)%m_nHashTableSize];

 CAssoc* pAssoc;
 for(pAssoc = *ppAssocPre; pAssoc != NULL; pAssoc = pAssoc->pNext)
 {
  if(pAssoc->key == key)
  {
   // 移除pAssoc指向的项
   *ppAssocPre = pAssoc->pNext;  // 从表中移除
   FreeAssoc(pAssoc);       // 释放内存
   return TRUE;
  }
  ppAssocPre = &pAssoc->pNext;
 }
 return FALSE; // 没有找到
}

CMapPtrToPtr::~CMapPtrToPtr()
{
 RemoveAll();
}

void CMapPtrToPtr::RemoveAll()
{
 if(m_pHashTable != NULL)
 {
  // 释放计算表
  delete[] m_pHashTable;
  m_pHashTable = NULL;
 }

 m_nCount = 0;
 m_pFreeList = NULL;
 m_pBlocks->FreeDataChain();
 m_pBlocks = NULL;
}

CMapPtrToPtr::CAssoc* CMapPtrToPtr::NewAssoc()
{
 // 预留的空间已经被使用完
 if(m_pFreeList == NULL)
 {
  // 向m_pBlocks指向的链中添加一个新的内存块。m_nBlockSize的值可以由用户指定
  CPlex* newBlock = CPlex::Create(m_pBlocks, m_nBlockSize, sizeof(CAssoc));

  // 将新内存块中各CAssoc结构添加到m_pFreeList指向的链中（空闲链）
  CAssoc* pAssoc = (CAssoc*)newBlock->data();
  pAssoc += m_nBlockSize -1; // 注意，此时pAssoc指向内存块中最后一个CAssoc结构 
  for(int i = m_nBlockSize -1; i >= 0; i--, pAssoc--)
  {
   // 将pAssoc做为链的首地址添加到空闲链中（还是以相反的顺序向链中添加元素）
   pAssoc->pNext = m_pFreeList; 
   m_pFreeList = pAssoc;
  }
 }

 // 从空闲链中取出一个元素pAssoc
 CAssoc* pAssoc = m_pFreeList;
 m_pFreeList = m_pFreeList->pNext; 
 m_nCount++;    // 又多使用了一个CAssoc结构

 // 初始化新关联的值
 pAssoc->key = 0;
 pAssoc->value = 0;
 return pAssoc;
}

void CMapPtrToPtr::FreeAssoc(CAssoc* pAssoc)
{
 // 将要释放的关联做为链的首地址添加到空闲链中（以相反的顺序）
 pAssoc->pNext = m_pFreeList;
 m_pFreeList = pAssoc;
 m_nCount--;    // 释放了一个CAssoc结构

 // 如果全部的关联都没被使用，就释放所有的内存空间，包括CPlex::Create函数申请的内存块
 if(m_nCount == 0)
  RemoveAll();  // 此函数会释放所有内存空间，待会儿我们再讨论
}

 

这样看，大家就都明白了，我的那个整好是把外面封包的部分给砍掉了。这个同样适合于在WINDOWS平台下

努力！！！！！！！！！！！！！

jogholy
关注
专栏目录
高并发内存池(ConCurrentMemoryPool)
qq_64341323的博客
02-22 2306
一、 项目概述 1. 简介 基于Google开源tcmalloc项目，该内存池主要应用于多线程频繁申请和释放大量小块内存。它的优点：性能卓越、大幅减少了外内存碎片。 2. 工具 Google的tcmalloc开源代码，使用vs2019进行研究学习。 3. 目标 1、 建立一个可行的私人高并发内存池，需要解决以下三个问题： a) 效率问题 b) 内存碎片问题 c) 多线程并发场景下的内存释放和申请的锁竞争问题。 2、 深入理解内存管理 4. 扩展 1、 完全脱离malloc和free，且不要使用thread和
java 内存池_内存池技术介绍（图文并茂，非常清楚）
weixin_42570769的博客
02-12 1960
看到一篇关于内存池技术的介绍文章，受益匪浅，转贴至此。6.1 自定义内存池性能优化的原理如前所述，读者已经了解到"堆"和"栈"的区别。而在编程实践中，不可避免地要大量用到堆上的内存。例如在程序中维护一个链表的数据结构时，每次新增或者删除一个链表的节点，都需要从内存堆上分配或者释放一定的内存；在维护一个动态数组时，如果动态数组的大小不能满足程序需要时，也要在内存堆上分配新的内存空间。6.1.1 默认...
内存池设计研究与应用
free_eyes的专栏
06-30 1228
今天在群里看见有人在讨论内存池的问题，呵呵，想到自己也写过一些内存池，在这里抛砖引玉。其实内存池的作用大家也知道，一般是解决大量的new和delete频繁操作引起的内存碎片，效率是一方面，另外长时间后的安全性也是一个问题。曾经看过《C++应用程序性能优化》里面的内存池结构，也看过ACE自己的自增式内存池结构，感觉每个都有自己的优点。但是大体思路都是一致的，那就是一次new出一大
内存池应用
学习笔记
12-22 1436
内存池技术详解里面已经很清楚地讲解了写一个内存池的方法了。而这里我结合游戏开发中的使用，说说内存池的应用。 首先不管怎么去应用，如果我们不去手动释放占有的资源，那么我们的内存总有用完的那么一天。 我们的内存池 class MemoryPool { struct Node { Node():next(NULL){} ~Node():next(NULL){} Node* next
内存池的使用
hankyt的博客
07-28 538
内存池的使用 内存池介绍 动态内存堆可以分配任意大小的内存块，非常灵活和方便。但其存在明显的缺点：一是分配效率不高，在每次分配时，都要进行空闲内存块查找；二是容易产生内存碎片。 为了提高内存分配的效率，并且避免内存碎片，RT-Thread 提供了另外一种内存管理方法：内存池(Memory Pool) 内存池是一种内存分配方式，用于分配大量大小相同的小内存块。使用内存池可以极大地加快内存分配与释放的速度，且能尽量避免内存碎片化。 RT-Thread的内存池支持线程挂起功能，当内存池中无空闲内存块时，申请线程会
内存池基础应用
sbdb23的博客
10-22 229
内存池基础应用 本文只涉及内存池的基本应用，代码以及学习资料来源于网络，刚兴趣的网友可以搜一下。我这里只是总结一下自己的想法，做一个搬运工。 再复杂的工程也离不开基础应用的实战变化，这就像上学时的教材课后习题其实才是学生最应该掌握的。基础没打好直接上附加题，没什么意义。 内存池的基础应用 嵌入式指针的应用 内存池存在的意义 频繁的malloc会使内存碎片化，尤其是频繁的malloc小块内存，浪费...
基于C++实现的连接池、线程池、内存池、对象池项目源码含项目说明.zip
05-31
基于C++实现的连接池、线程池、内存池、对象池项目源码含项目说明.zip ## CPP连接池 ### 关键技术点 MySQL数据库编程、单例模式、queue队列容器、C++11多线程编程、线程互斥、线程同步通信和 unique_lock、基于CAS的...
性能优化-内存池的设计和实现，看这篇文章就够了
lt_xiaodou的博客
09-27 964
在之前的文章中，我们分析了glibc内存管理相关的内容，里面的是不是逻辑复杂，毕竟咱们用几十行代码完成的功能，glibc要用上百乃至上千行代码来实现，毕竟它的受众太多了，需要考虑跨平台，各种边界条件等。其实，glibc的内存分配库ptmalloc也可以看做是一个内存池，出于性能考虑，每次内存申请都是先从ptmalloc中进行分配，如果没有合适的则通过系统分配函数进行申请；在释放的时候，也是将被释放内存先方式内存池中，内存池根据一定的策略，来决定是否进行shrink以归还OS。那么，发现一个内存池？
数据库连接池技术在分布式系统中的应用研究.pdf
08-11
在深入探讨数据库连接池技术的原理和应用之前，我们先来了解Web技术的快速发展是如何影响到Web应用系统性能要求的。随着互联网技术的飞速发展，Web应用已经广泛地应用于电子商务和企业级应用系统中。随着Web应用的...
简单内存池模块详细设计
08-12
内存池技术通过对内存的预先分配和复用来提高内存管理效率，特别适用于频繁分配和释放相同大小内存的场景。通过使用内存池，不仅可以减少系统调用的次数，还可以避免内存碎片化问题，进而显著提升程序的整体性能。在...
内存池实现原理 (中文)
05-30
自定义内存池的思想通过这个"池"字表露无疑，应用程序可以通过系统的内存分配调用预先一次性申请适当大小的内存作为一个内存池，之后应用程序自己对内存的分配和释放则可以通过这个内存池来完成。只有当内存池大小需要动态扩展时，才需要再调用系统的内存分配函数，其他时间对内存的一切操作都在应用程序的掌控之中。
几种内存池的实现(c/c++ 源码)
07-25
几种 内存池 的实现 (c/c++ 源码)
apr内存池简单应用
xiao2macf的专栏
05-22 676
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、内存池接口简介1、初始化2、创建内存池3、使用内存池分配内存4、释放内存和销毁内存池二、使用步骤1.引入库三、调用示例总结 前言 libapr大部分接口函数内部申请内存和释放内存，都会用到内存池。 提示：以下是本篇文章正文内容，下面案例可供参考 一、内存池接口简介 1、初始化 /** * Setup all of the internal structures required to use pools * @re.
内存池（Memory Pool）
最新发布
xiaofeilongyu的博客
06-11 975
内存池预先从操作系统申请一大块连续内存空间，并将其管理起来，当程序需要分配内存时，不再直接向操作系统请求，而是从内存池中快速分配一小块事先准备好的内存单元。当不再需要这些内存时，也不是直接归还给操作系统，而是归还给内存池，由内存池统一管理，适时或在程序结束时再归还给操作系统。内存池（Memory Pool）是一种内存管理技术，主要用于优化程序中动态内存分配和释放的效率，减少内存碎片，提高程序运行速度。: 释放内存时，不是直接还给系统，而是归还给内存池，可能需要进行合并相邻空闲块的操作以减少碎片。
使用内存池的原因，内存池的应用
滴水穿石
09-14 2463
网络游戏服务器开发技术  -------如何正确高效的使用内存和对象内存池？    大家都知道，游戏服务器在网络游戏开发中所占的比重。而评论游戏服务器的好坏标准，除了实现游戏的逻辑功能外，最重要的也就是稳定和高效。一个不稳定的服务器对于一款网络游戏的打击是沉重，一个不高效的服务器对于玩家的感觉也是非常明显的。 在这一章节中，我将要向大家介绍游戏服务器高效开发的一个方面，如何正确高效的使用
内存池的实现与场景分析
kakaka666的博客
09-20 458
内存池的实现与场景分析
MFC基于CPlex结构的内存池化管理
Maybe
08-27 499
转自：http://blog.csdn.net/phunxm/article/details/5676520 CMapPtrToPtr的内存管理问题 CMapPtrToPtr类保存的是若干个映射项的集合。每个映射项保存了一对映射关系，一个称为键（key），相当于数学中的 x，另一个称为值（value），相当于y。为了将这些映射关系连在一起，还要在每个映射项中记录下下一个映射项的地址，所以可
C++ 内存池（翻译）
10-05 169
原帖与示例代码地址：http://www.codeproject.com/KB/cpp/MemoryPool.aspx 译者点评：一个简单的内存池实现，附有源码，简单易懂，适合入门。 概述 在c/c++中，内存分配（如malloc或new）会使用很多时间。 一个程序会随着长时间的运行和内存的申请释放而变得越来越慢，内存也会随着时间逐渐碎片化。特别是高频率的进行小内存申...
链表实现内存池技术详解
- 如果链表为空，说明内存池已耗尽，此时可能需要扩展内存池（即再次向操作系统申请内存并划分）。 3. 内存释放： - 释放内存时，不是直接返回给操作系统，而是将内存块放回链表的头部，供后续的内存分配使用。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值