内存池

最新推荐文章于 2024-07-29 17:54:58 发布
最新推荐文章于 2024-07-29 17:54:58 发布
阅读量112 收藏
点赞数
分类专栏： 内存池 文章标签： 内存管理 malloc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holidaywu/article/details/105992223
版权

内存池主要文件:MemoryMgr.h

 

#ifndef _MemoeyMgr_hpp_
#define _MemoeyMgr_hpp_

#include<stdlib.h>
#include<assert.h>
#include<iostream>


#define MAX_MEMORY_SIZE 128
class MemoryAlloc;
class MemoryMgr;


//内存块 最小单元
class MemoryBlock{

public:

    //内存块编号
    int nID;
    //引用次数
    size_t nRef;
    //所属最大内存块
    MemoryAlloc* pAlloc;
    // 下一块位置
    MemoryBlock* pNext;
    //是否在内存池中
    bool bPool;

private:
    //预留
    char c1;
    char c2;
    char c3;
};

 


//内存池
class MemoryAlloc{

public:
    MemoryAlloc(){
        _pBuf = nullptr;
        _pHeader = nullptr;
        _nSize = 0;
        _nBlockCount = 0;
    }


    ~MemoryAlloc(){
        if (_pBuf){
            free(_pBuf);
        }
    }

    //初始化内存池
    void initMemory(){
        //断言
        
        assert(nullptr == _pBuf);
        if (nullptr != _pBuf)
            return;

        //向系统申请内存池内存

        size_t bufsize = (_nSize+sizeof(MemoryBlock))*_nBlockCount;
        _pBuf = (char*)malloc(bufsize);


        
        //初始化内存池
        _pHeader = (MemoryBlock*)_pBuf;
        _pHeader->bPool = true;
        _pHeader->nID = 1;
        _pHeader->nRef = 0;
        _pHeader->pAlloc = this;
        _pHeader->pNext = nullptr;

        MemoryBlock* pTemp1 = _pHeader;

        for (size_t n = 2; n < _nBlockCount; n++){

            MemoryBlock* pTemp2 = (MemoryBlock*)(_pBuf + (n*(_nSize + sizeof(MemoryBlock))));

            pTemp2->bPool = true;
            pTemp2->nID = n;
            pTemp2->nRef = 0;
            pTemp2->pAlloc = this;
            pTemp2->pNext = nullptr;
            pTemp1->pNext =pTemp2;
            pTemp1 = pTemp2;

        }
    }

    //外部向内存池申请内存
    void*  allocMemmory(size_t nSize){
        if (nullptr==_pBuf){
            initMemory();

        }

        MemoryBlock* pReturn = nullptr;
        if (nullptr == _pHeader){
            
            pReturn = (MemoryBlock*)malloc(nSize + sizeof(MemoryBlock));
            pReturn->bPool = false;
            pReturn->nID = -1;
            pReturn->nRef = 1;
            pReturn->pAlloc = nullptr;
            pReturn->pNext = nullptr;
            

        }
        else{

            pReturn = _pHeader;
            _pHeader = _pHeader->pNext;
            assert(0 == pReturn->nRef);
            std::cout << "allocMem" << pReturn << ",id=" << pReturn->nID << ",size=" << nSize << std::endl;
            pReturn->nRef = 1;
        
        }
        //返回的内存空间也没有MemoryBlock的包头
        return ((char*)pReturn + sizeof(MemoryBlock));
    }


    //内存池释放内存
    void freeMemory(void* pMem){
        
        //传进来的值没有MemoryBlock的包头
        //所以传进来的指针需要向左移动sizeof（MemoryBlock）个字节
        MemoryBlock* pBlock=(MemoryBlock*)((char*)pMem - sizeof(MemoryBlock));
        assert(1 == pBlock->nRef);
        if (--pBlock->nRef != 0){
            return ;
        }
        if (pBlock->bPool){
            
        
            pBlock->pNext = _pHeader;
            _pHeader = pBlock;

        }
        else{
            free(pBlock);
        }
    
    }

protected:
    //内存池地址
    char* _pBuf;
    //头部单元内存
    MemoryBlock* _pHeader;
    // 内存单元的大小
    size_t _nSize;
    // 内存单元的数量
    size_t _nBlockCount;

    
};

//便于声明类成员利用模板。

template<size_t nSize,size_t nBlocksize>
class MemoryAllocator:public MemoryAlloc{

public:
    MemoryAllocator()
    {
        const int n = sizeof(void*);

        _nSize = (nSize/n) * n+(nSize/n?0:n);
        _nBlockCount = nBlocksize;
    }

};

 


//内存管理工具
class MemoryMgr{

private:

    MemoryMgr(){
        init_Mem(0, 32, &_mem32);
        init_Mem(33, 64, &_mem64);
        init_Mem(65, 128, &_mem128);
    }
    ~MemoryMgr(){

    }

public:

    //单例模式
     static MemoryMgr& Instance(){
        
        static MemoryMgr mgr;
        return mgr;

    }
     //申请内存
    void* allocMem(size_t nSize){

        if (nSize <= MAX_MEMORY_SIZE){

            return _szAlloc[nSize]->allocMemmory(nSize);

        }
        else{
            MemoryBlock* pReturn = (MemoryBlock*)malloc(nSize + sizeof(MemoryBlock));
            pReturn->bPool = false;
            pReturn->nID = -1;
            pReturn->nRef = 1;
            pReturn->pAlloc = nullptr;
            pReturn->pNext = nullptr;
            //pReturn的地址
            //xPrintf("allocMem:%llx，id=%d，size=%d\n", pReturn,pReturn->nID, nSize);
            std::cout << "allocMem" << pReturn << ",id=" << pReturn->nID << ",size=" << nSize << std::endl;
            return ((char*)pReturn+sizeof(MemoryBlock));
        }
        
    }

    //释放内存
    void freeMem(void* pMem){

        MemoryBlock* pBlock = (MemoryBlock*)((char*) pMem - sizeof(MemoryBlock));

        std::cout << "allocMem" << pBlock << ",id=" << pBlock->nID << std::endl;

        if (pBlock->bPool){
            pBlock->pAlloc->freeMemory(pMem);
        }
        else
        {
            if (--pBlock->nRef == 0){
                free(pBlock);
            }
        }

    }

    void addRef(void* pMem){
        MemoryBlock* pBlock = (MemoryBlock*)((char*)pMem - sizeof(MemoryBlock));
        ++pBlock->nRef;
    }
private:

    //初始化内存池映射数组
    void init_Mem(int nBegin, int nEnd, MemoryAlloc* pMemA){

        for (int n = nBegin; n <= nEnd; n++){
            //
            _szAlloc[n] = pMemA;
        }

    }


private:
    MemoryAllocator<64, 10> _mem64;
    MemoryAllocator<128, 10> _mem128;
    MemoryAllocator<32, 10> _mem32;

    //存放每个所需内存大小的的每个对应内存池地址
    MemoryAlloc* _szAlloc[MAX_MEMORY_SIZE + 1];

};


#endif

 

 

分配内存的头文件：Alloctor.h

#ifndef _ALLOCTOR_H_
#define _ALLOCTOR_H_


void* operator new(size_t size);

void operator delete(void* p);

void* operator new[](size_t size);

void operator delete[](void* p);

void* mem_alloc(size_t size);

void mem_free(void* p);

#endif

分配内存的cpp文件：Alloctor.cpp

 

#include"Alloctor.h"
#include<stdlib.h>
#include"MemoryMgr.h"


void* operator new(size_t size){

    return MemoryMgr::Instance().allocMem(size);

}

void operator delete(void* p){

    MemoryMgr::Instance().freeMem(p);

}


void* operator new[](size_t size){

    return MemoryMgr::Instance().allocMem(size);

}

 

void operator delete[](void* p){

    MemoryMgr::Instance().freeMem(p);

}


void* mem_alloc(size_t size){

    return malloc(size);
}

void mem_free(void* p){
    free(p);

}

 

holidaywu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内存池设计与实现
shawn的专栏
06-29 7万+
1. 内存池设计1.1 目的 在给定的内存buffer上建立内存管理机制，根据用户需求从该buffer上分配内存或者将已经分配的内存释放回buffer中。1.2 要求 尽量减少内存碎片，平均效率高于C语言的malloc和free。1.3 设计思路 将buffer分为四部分，第1部分是mem_pool结构体；第2部分是内存映射表；第3部分是内存chunk结构体缓冲区；第4部分
易语言内存池申请
07-20
内存池是一种优化内存管理的技术，尤其在嵌入式系统或高性能计算中常见。在易语言中，内存池的实现能够帮助开发者更有效地管理和分配内存，减少碎片，提高程序运行效率。下面将详细介绍“易语言内存池申请”相关知识...
C++ 内存池实现 并管理内存池（支持多线程）
时间溜走了的博客
06-01 782
Alloctor.h: #ifndef _ALLOCTOR_H_ #define _ALLOCTOR_H_ void* operator new(size_t size); void operator delete(void* p); void* operator new[](size_t size); void operator delete[](void* p); void* mem_alloc(size_t size); void mem_free(void* p); #endif .
boost库 内存池
最新发布
weixin_50873490的博客
07-29 1027
简单轻量:它是一个基础的内存管理工具,实现简单,开销较小。高效:通过维护内存块列表,可以快速分配和回收内存。可定制:提供了许多可配置的选项,如内存块大小、对齐方式等。可重用:可以被上层的内存池实现 (如) 重复利用。内存池管理Boost.Pool 提供了两种主要的内存池实现:和。它们都利用来管理内存块,提高内存利用率和缓存命中率。固定大小对象管理Boost.Pool 专注于管理固定大小的对象,这种设计能够提高内存管理的效率。它使用连续的内存块来存储这些对象,避免了频繁的new和。
内存池的设计与实现
anrui0096的博客
06-02 77
目的 内存池的作用在于消除频繁调用系统默认的内存分配和释放函数所带来的开销问题。 由于每次要求分配的内存大小不等，使用默认的内存分配函数的话，可能给系统带来大量的碎片问题，所以，将内存配置问题交给底层的内存池去处理，是一个不错的选择。 设计 本来打算自己实现一个内存池，想了想还是算了。总结这篇文章的目的在于深入剖析内存池相关内容，主要是相关思想，而不在于代码实现上。所以，通过STL的底层...
高效内存池；动态内存池|单元内存池-易语言
06-12
模块提供2个类，包括 单元内存池、动态内存池；使用内存池能极大的提高内存分配效率，并且能相应减少系统内存碎片。 -------- 单元内存池 单元内存池是以一个固定的单元长度为分配内存长度的内存池，只能分配固定...
c++高性能内存池.rar
03-27
std::allocator 是 C++标准库中提供的默认分配器，他的特点就在于我们在 使用 new 来申请内存构造新对象的时候，势必要调用类对象的默认构造函数 ...所以为了让代码直接可用，我们同样应该在内存池中设计同样的接口：
C++ Nginx内存池源码与使用
10-11
- 内存池中的内存块一旦分配，就不会被释放回操作系统，而是保留供后续使用，直到整个内存池被释放。 2. **Nginx内存池结构** - Nginx内存池由一系列的内存块（pool）组成，每个内存块包含一组连续的小块内存。 ...
内存池的介绍与设计详解
08-10
内存池是一系列固定大小的内存空间，每一个内存池主要包括很多内存单元（具体的存储区域）和内存控制单元（控制对应的内存单元），每一个内存单元大小相同，但是具体的大小依据需要设计。而控制单元主要是实现每一个子内存空间的控制，因此采用一一对应的方式，每一个具体的子内存空间分配一个控制单元。
C++多线程内存池和简单的BUFFER类
08-16
C++多线程内存池和简单的BUFFER类。C++多线程内存池和简单的BUFFER类
简易的内存池实现
07-16
简单的内存池实现,已经应用到一个小项目中,使用方法看头文件吧,代码也不多.
【 C++ 】 内存池
Ambition_HAO的博客
07-27 191
一、内存池简介 内存池是池化技术中的一种形式。通常我们在编写程序的时候回使用 new delete 这些关键字来向操作系统申请内存，而这样造成的后果就是每次申请内存和释放内存的时候，都需要和操作系统的系统调用打交道，从堆中分配所需的内存。如果这样的操作太过频繁，就会找成大量的内存碎片进而降低内存的分配性能，甚至出现内存分配失败的情况。 而内存池就是为...
内存池设计与实现 .
fendouxiaoxiaoniao的专栏
04-30 410
原地址：http://blog.csdn.net/shawngucas/article/details/6574863
C语言——内存池的设计和实现
weixin_40203143的博客
12-24 2881
看完了之前两套代码后，我打算自己动手实现一个简单的内存池，我的思路与代码二类似，这样做的好处是可以给不同的对象使用不同的内存池，可以相互隔绝：memorypool下面挂一个memory的链表，可以选择动态扩展长度，每次分配和回收都以memory为单位;memorypool中的free_list 采用单链表实现，used_list采用双链表实现，因为考虑到，分配给某个对象实例一个内存空间后，方便查看...
多线程内存管理
11-13 3392
<br />  原文：http://yachang.wang.blog.163.com/blog/static/35551220200762753057335/<br /> <br />  假设有一个进程，创建了两个线程A、B，线程A在堆上分配了一块内存空间，通知传指针的方式在B中使用，使用完后释放块，这时就会出错，因为线程B不能释放线程A堆上的内存空间，一些网友对此也有一些看法。 <br />       “有点经验可以告诉你，每个线程都有自己的堆栈，而它们共享进程的一个全局堆，NEW是在线程的局部堆
Apache内存池技术详解
"Apache内存池内幕" Apache内存池是Apache HTTP Server和APR（Apache Portable Runtime）库中的一个重要概念，它是一种高效、集中的内存管理机制，用于解决大规模服务中的内存分配与释放问题。内存池的设计目标是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值