优化资源利用，用C++内存池点亮编程之路

内存池介绍(Memory Pool):

它是一种内存分配方式，通过预先分配和复用内存块。

在真正使用内存之前，先申请一大块内存备用。当有新的内存需求时，就从内存池中分出一部分内存块，

若内存块不够再继续申请新的内存。如果我们不需要继续使用当前的内存块了，那么就还给内存池。
在这里插入图片描述

为什么要使用内存池

1、内存分配和释放通常涉及系统调用（如malloc和free | new 和 delete ），这些系统调用需要用户态和内核态之间的切换，频繁的系统调用开销较大。内存池是提前分配一块内存，后续我们的内申请都是从内存池中申请，不需要进行系统调用，从而降低了开销。

2、当程序频繁地申请和释放不同大小的内存块时，容易导致内存碎片。

3、传统的内存分配和释放通常涉及到复杂的算法和数据结构（如堆），以及可能的线程同步操作，这些都会消耗较多的CPU时间。而内存池通过预先分配并管理固定大小的内存块，可以大大简化这些操作，从而提高效率。

所以如果我们需要频繁分配和释放小块内存 或者 需要大量内存分配和释放，那么建议使用内存池来高效管理内存。

内存池的实现

内存池的相关接口、必要的属性。MemoryPool.h

#ifndef  _MEMORY_POOL_H_
#define _MEMORY_POOL_H_

#include <iostream>
#include <string.h>
#include <vector>
#include <mutex>

#define SIZE 1024 * 1024 

class MemoryPool{
public:
    // 创建一个内存池， 单列模式，因为整个项目只需要一个内存池
    static MemoryPool& getInstance(){

        // 内存池默认大小是 1G  每块大小是1024字节
        static  MemoryPool memoryPool_( 1024* SIZE , 1024); // 1024 = 1KB * 1024  = 1mb *1024 = 1gb   
        
        return memoryPool_;
    }

    void *calloc_locate(size_t  size);  // 分配内存
    void delete_locate(void *ptr);   // 释放内存

private:
    MemoryPool(size_t pool_size , size_t block_size);
    ~MemoryPool();
    void init_memPool();   // 初始化内存池

    char *pool_;            // 内存池指针
    size_t pool_size_;    // 内存池的大小
    size_t block_size_;    // 每一块内存的大小
    std::vector<bool>use_block_;  // 每个内存块的使用情况
    std::mutex mutex_;     // 由于内存池是共享资源 , 所以在进行操作时要加锁
};

#endif  // _MEMORY_POOL_H_

对相关接口进行实现 MemoryPool.cpp

#include "MemoryPool.h"

 MemoryPool::MemoryPool(size_t pool_size , size_t block_size){
      pool_size_ = pool_size;
      block_size_ = block_size;
      pool_ = new char[pool_size];
      std::cout<<"Memory Start: "<<static_cast<void *>(pool_)<<std::endl;
      init_memPool();
 }

 void MemoryPool::init_memPool(){
    // 内存分成的块数 = 内存池的总大小 / 每块的大小 
    use_block_.resize( pool_size_/block_size_ , false);
 }

 MemoryPool::~MemoryPool(){
    // 对整个内存池资源进行清理
    if( pool_ ){
        delete[] pool_;
        pool_ = nullptr;
        pool_size_ = 0;
        block_size_ = 0;
        use_block_.reserve(0);
    }
 }

 void *MemoryPool::calloc_locate(size_t  size){
    if( size > block_size_ ){  // 如果我们要分配的内存 ，大于我们每块的大小 
        return nullptr;
    }
    std::unique_lock<std::mutex> lock(mutex_);

    for(int i = 0 ;i < pool_size_ ;i += block_size_ ){
        if( !use_block_[i/block_size_]){  //当前块没有被使用过
            use_block_[i/block_size_] = true;
            std::cout<<"successful calloc_locate ptr: "<<static_cast<void *>(pool_ + i) <<std::endl;
            return pool_ + i ; 
        }
    }
     std::cout<<"Failed calloc_locate ptr: "<<std::endl;
    // 内存池资源耗尽的情况
    return nullptr;
 }

void MemoryPool::delete_locate(void *ptr){
    if( !ptr )  return ;
    if( ptr< pool_  || ptr > pool_ ){  // 需要释放的内存不在我们内存池范围内
        return ;
    }
    std::cout<<"delete ptr: "<<std::hex<<ptr<<std::endl;
    // 将指针进行对齐
    /*
        ptr = 100 -> 需要删除内存的起始位置
        pool_ -----> 内存池的起始位置    
    */
    std::unique_lock<std::mutex>lock;
    auto index = (reinterpret_cast<char *>(ptr) - pool_ )/block_size_;
    if( index >=0 && index <use_block_.size()){
        use_block_[index] = false;
        std::cout<<"Delete successful"<<std::endl;
        return ;
    }
    std::cout<<"Delete Failed"<<std::endl;
}

测试demo test.cpp

#include "MemoryPool.h"

int main(int ,char **){

    MemoryPool &pool = MemoryPool::getInstance();
    // 分配1kb
    char *ptr = reinterpret_cast<char *>(pool.calloc_locate(1024));
    if(!ptr)  return 1;
    std::cout<<"ptr: "<< static_cast<void *>(ptr)<<std::endl;

    char *ptr2 = reinterpret_cast<char *>(pool.calloc_locate(800));
    if(!ptr2)  return 1;
    std::cout<<"ptr: "<< static_cast<void *>(ptr2)<<std::endl;

    pool.delete_locate(ptr);
   
   return 0;
}