C++ 内存池（Memory Pool）详解

server/2024/10/9 2:01:58/

1. 基本概念

内存池是一种内存管理技术，旨在提高内存分配的效率。它通过预先分配一块大的内存区域（池），然后从中分配小块内存来满足应用程序的需求。这样可以减少频繁的内存分配和释放带来的性能开销。

2. 设计思路

内存池的设计通常遵循以下步骤：

  • 预分配内存：在程序开始时，预先分配一块较大的内存区域。
  • 管理空闲块：使用链表、栈或数组等数据结构管理可用内存块。
  • 分配和释放：提供分配和释放接口，让用户从内存池中获取和释放内存。
  • 回收机制：当内存块被释放时，将其返回到内存池中，便于后续使用。

3. 原理

内存池的核心原理是降低内存分配的时间复杂度。标准的 new 和 delete 操作在需要内存时会与操作系统频繁交互，可能会造成较大的开销。而内存池将这种频繁操作集中到池的初始化阶段，后续的分配和释放则在池内进行，速度更快。

4. 使用场景

内存池适用于以下场景：

  • 游戏开发：频繁创建和销毁对象，例如子弹、敌人等。
  • 高性能计算：实时系统对内存分配速度的高要求。
  • 网络编程：处理大量小数据包时，内存池可以提高性能。
  • 嵌入式系统：资源有限的环境中，避免频繁的动态内存分配。

5. 详细讲解

  • 内存池的优势：

    • 性能提升：通过减少系统调用，提高内存分配和释放的速度。
    • 内存碎片减少：通过统一管理，减少内存碎片的问题。
    • 简化内存管理：可以设计为自动回收机制，降低内存泄漏的风险。

  • 内存池的劣势：

    • 内存浪费：如果分配的块未被充分利用，可能会造成内存浪费。
    • 复杂性增加：需要额外的代码管理内存池，增加了系统的复杂性。

  • 扩展功能：

    • 多线程支持：在多线程环境中，可以使用锁或无锁队列管理内存池。
    • 调试功能：可以在分配和释放时记录堆栈信息，便于调试内存泄漏。

6. 场景示例

内存池的详细实现

1. 内存池类的结构

内存池主要由以下几个部分构成：

  • 内存块：固定大小的内存单元。
  • 内存池管理：负责分配和释放内存块。
  • 空闲块管理：使用链表或栈来管理未使用的内存块。
2. 经典的内存池实现

#include <iostream>
#include <vector>
#include <stdexcept>
#include <cassert>

class MemoryPool {
public:
    // 构造函数，初始化内存池
    MemoryPool(size_t blockSize, size_t blockCount)
        : m_blockSize(blockSize), m_blockCount(blockCount), m_usedBlocks(0) {
        // 分配内存池
        m_pool = malloc(blockSize * blockCount);
        if (!m_pool) {
            throw std::bad_alloc(); // 内存分配失败，抛出异常
        }
        // 初始化空闲块列表
        for (size_t i = 0; i < blockCount; ++i) {
            m_freeBlocks.push_back(static_cast<char*>(m_pool) + i * blockSize);
        }
    }

    // 析构函数，释放内存池
    ~MemoryPool() {
        free(m_pool);
    }

    // 分配内存块
    void* allocate() {
        // 如果没有可用的块，返回nullptr
        if (m_freeBlocks.empty()) {
            return nullptr; // 可以改进为扩展内存池
        }
        // 从空闲块列表中取出一个块
        void* block = m_freeBlocks.back();
        m_freeBlocks.pop_back(); // 从空闲列表中移除
        m_usedBlocks++; // 增加使用计数
        return block; // 返回分配的块
    }

    // 释放内存块
    void deallocate(void* block) {
        assert(block != nullptr); // 确保要释放的块不是nullptr
        m_freeBlocks.push_back(static_cast<char*>(block)); // 添加到空闲块列表
        m_usedBlocks--; // 减少使用计数
    }

    // 获取当前使用的块数
    size_t usedBlocks() const {
        return m_usedBlocks;
    }

    // 获取空闲块的数量
    size_t freeBlocks() const {
        return m_freeBlocks.size();
    }

private:
    size_t m_blockSize;            // 每个内存块的大小
    size_t m_blockCount;           // 内存池中的块数量
    void* m_pool;                  // 内存池的起始地址
    std::vector<void*> m_freeBlocks; // 存储空闲块的列表
    size_t m_usedBlocks;           // 当前使用的块数
};

// 示例使用
int main() {
    const size_t BLOCK_SIZE = 32; // 每个块32字节
    const size_t BLOCK_COUNT = 10; // 总共10个块

    MemoryPool pool(BLOCK_SIZE, BLOCK_COUNT); // 创建内存池

    // 分配内存块
    void* block1 = pool.allocate();
    void* block2 = pool.allocate();

    std::cout << "Allocated blocks: " << block1 << ", " << block2 << std::endl;
    std::cout << "Used blocks: " << pool.usedBlocks() << std::endl;
    std::cout << "Free blocks: " << pool.freeBlocks() << std::endl;

    // 释放内存块
    pool.deallocate(block1);
    pool.deallocate(block2);

    std::cout << "After deallocation:" << std::endl;
    std::cout << "Used blocks: " << pool.usedBlocks() << std::endl;
    std::cout << "Free blocks: " << pool.freeBlocks() << std::endl;

    return 0;
}

3. 详细讲解
3.1 内存池的工作原理
  • 初始化：在创建内存池时，预先分配一大块内存，分成多个固定大小的内存块。
  • 分配：当请求内存时，从空闲块列表中取出一个块并返回。如果没有空闲块，可以考虑扩展内存池。
  • 释放：释放时将内存块返回到空闲块列表中，便于后续使用。
3.2 主要功能说明
  • allocate()：从空闲块中分配一个块，返回其地址；如果没有可用块，返回 nullptr。
  • deallocate()：将已使用的内存块返回到空闲块列表中。
  • usedBlocks() 和 freeBlocks()：分别返回当前使用的块数和空闲块数，便于监控内存使用情况。
4. 扩展使用示例
4.1 用于游戏对象管理

假设我们有一个游戏中的子弹对象，我们可以使用内存池来管理这些对象的创建和销毁。

#include <iostream>
#include <vector>
#include <stdexcept>
#include <cassert>

class MemoryPool {
public:
    // 构造函数，初始化内存池
    MemoryPool(size_t blockSize, size_t blockCount)
        : m_blockSize(blockSize), m_blockCount(blockCount), m_usedBlocks(0) {
        // 分配内存池
        m_pool = malloc(blockSize * blockCount);
        if (!m_pool) {
            throw std::bad_alloc(); // 内存分配失败，抛出异常
        }
        // 初始化空闲块列表
        for (size_t i = 0; i < blockCount; ++i) {
            m_freeBlocks.push_back(static_cast<char*>(m_pool) + i * blockSize);
        }
    }

    // 析构函数，释放内存池
    ~MemoryPool() {
        free(m_pool);
    }

    // 分配内存块
    void* allocate() {
        // 如果没有可用的块，返回nullptr
        if (m_freeBlocks.empty()) {
            return nullptr; // 可以改进为扩展内存池
        }
        // 从空闲块列表中取出一个块
        void* block = m_freeBlocks.back();
        m_freeBlocks.pop_back(); // 从空闲列表中移除
        m_usedBlocks++; // 增加使用计数
        return block; // 返回分配的块
    }

    // 释放内存块
    void deallocate(void* block) {
        assert(block != nullptr); // 确保要释放的块不是nullptr
        m_freeBlocks.push_back(static_cast<char*>(block)); // 添加到空闲块列表
        m_usedBlocks--; // 减少使用计数
    }

    // 获取当前使用的块数
    size_t usedBlocks() const {
        return m_usedBlocks;
    }

    // 获取空闲块的数量
    size_t freeBlocks() const {
        return m_freeBlocks.size();
    }

private:
    size_t m_blockSize;            // 每个内存块的大小
    size_t m_blockCount;           // 内存池中的块数量
    void* m_pool;                  // 内存池的起始地址
    std::vector<void*> m_freeBlocks; // 存储空闲块的列表
    size_t m_usedBlocks;           // 当前使用的块数
};


class Bullet {
public:
    Bullet(int x, int y) : m_x(x), m_y(y) {
        std::cout << "Bullet created at (" << x << ", " << y << ")\n";
    }
    ~Bullet() {
        std::cout << "Bullet destroyed\n";
    }
    // 其他Bullet方法...

private:
    int m_x, m_y; // 子弹位置
};

class BulletPool {
public:
    BulletPool(size_t size) : m_pool(sizeof(Bullet), size) {}

    Bullet* acquire(int x, int y) {
        void* mem = m_pool.allocate();
        if (!mem) return nullptr; // 如果没有可用的子弹，返回nullptr
        return new (mem) Bullet(x, y); // 使用placement new创建Bullet
    }

    void release(Bullet* bullet) {
        bullet->~Bullet(); // 显式调用析构函数
        m_pool.deallocate(bullet); // 将内存块返回到池中
    }

private:
    MemoryPool m_pool; // 内存池实例
};

// 示例使用
int main() {
    BulletPool bulletPool(5); // 创建一个可容纳5个子弹的池

    Bullet* bullet1 = bulletPool.acquire(10, 20);
    Bullet* bullet2 = bulletPool.acquire(15, 25);

    bulletPool.release(bullet1); // 释放子弹
    bulletPool.release(bullet2); // 释放子弹

    return 0;
}

4.2 高性能数据处理

在需要处理大量小数据结构时，内存池可以显著提高性能：

#include <iostream>
#include <vector>
#include <stdexcept>
#include <cassert>

class MemoryPool {
public:
    // 构造函数，初始化内存池
    MemoryPool(size_t blockSize, size_t blockCount)
        : m_blockSize(blockSize), m_blockCount(blockCount), m_usedBlocks(0) {
        // 分配内存池
        m_pool = malloc(blockSize * blockCount);
        if (!m_pool) {
            throw std::bad_alloc(); // 内存分配失败，抛出异常
        }
        // 初始化空闲块列表
        for (size_t i = 0; i < blockCount; ++i) {
            m_freeBlocks.push_back(static_cast<char*>(m_pool) + i * blockSize);
        }
    }

    // 析构函数，释放内存池
    ~MemoryPool() {
        free(m_pool);
    }

    // 分配内存块
    void* allocate() {
        // 如果没有可用的块，返回nullptr
        if (m_freeBlocks.empty()) {
            return nullptr; // 可以改进为扩展内存池
        }
        // 从空闲块列表中取出一个块
        void* block = m_freeBlocks.back();
        m_freeBlocks.pop_back(); // 从空闲列表中移除
        m_usedBlocks++; // 增加使用计数
        return block; // 返回分配的块
    }

    // 释放内存块
    void deallocate(void* block) {
        assert(block != nullptr); // 确保要释放的块不是nullptr
        m_freeBlocks.push_back(static_cast<char*>(block)); // 添加到空闲块列表
        m_usedBlocks--; // 减少使用计数
    }

    // 获取当前使用的块数
    size_t usedBlocks() const {
        return m_usedBlocks;
    }

    // 获取空闲块的数量
    size_t freeBlocks() const {
        return m_freeBlocks.size();
    }

private:
    size_t m_blockSize;            // 每个内存块的大小
    size_t m_blockCount;           // 内存池中的块数量
    void* m_pool;                  // 内存池的起始地址
    std::vector<void*> m_freeBlocks; // 存储空闲块的列表
    size_t m_usedBlocks;           // 当前使用的块数
};


class Data {
public:
    Data(int value) : m_value(value) {}
    ~Data() {}
    // 数据处理方法...

private:
    int m_value; // 数据值
};

class DataPool {
public:
    DataPool(size_t size) : m_pool(sizeof(Data), size) {}

    Data* create(int value) {
        void* mem = m_pool.allocate();
        return new (mem) Data(value); // 使用placement new创建数据对象
    }

    void destroy(Data* data) {
        data->~Data(); // 显式调用析构函数
        m_pool.deallocate(data); // 将内存块返回到池中
    }

private:
    MemoryPool m_pool; // 内存池实例
};

// 示例使用
int main() {
    DataPool dataPool(100); // 创建一个可容纳100个Data对象的池

    Data* data1 = dataPool.create(42);
    Data* data2 = dataPool.create(99);

    dataPool.destroy(data1); // 释放数据
    dataPool.destroy(data2); // 释放数据

    return 0;
}

7. 总结

内存池是一种有效的内存管理技术，通过预分配和集中管理内存块，提高了内存分配和释放的效率。尽管它增加了一定的复杂性，但在高性能和实时系统中，它的优势往往是不可忽视的。理解内存池的基本概念、设计思路和使用场景，有助于在适当的地方应用这一技术。


http://www.ppmy.cn/server/126360.html

相关文章

在Linux中创建检查点并还原的工具——criu

在Linux中创建检查点并还原的工具——criu

相信很多用过Unix系统的人都不会对 ctrlz 的 job 挂起不会陌生&#xff0c;然而这个功能却只能在用户空间中&#xff0c;而不能在磁盘上持久化就感觉对PC用户不是非常完美。而最近我发现一个叫criu的工具通过kernel直接镜像进程的cpu和内存状态存储的本地磁盘。 安装 这里我建…
阅读更多...
frp部署

frp部署

frp部署 下载frp配置frps服务器frpc配置将frpc部署进项目两个不同ip的主机连接frps 下载frp 目前下载的是frp5.9版本&#xff0c;&#xff08;6.0使用的时候有问题&#xff09;。将压缩包上传服务器并解压&#xff1a; 进入frp5.9的目录&#xff1a; 配置frps服务器 frps.tom…
阅读更多...
Node JS 安装

Node JS 安装

系统环境 [root@vm-10-176-30-167 ~]# cat /etc/redhat-release CentOS release 6.6 下载 nodejs 下载地址：https://nodejs.org/en/download/ 我下载的是Linux Binaries (.tar.gz) 64-bit 解压 [root@vm-10-176-30-167 letv]# tar xzvf node-v4.2.2-linux-x64.tar.gz [r…
阅读更多...
51单片机——矩阵键盘

51单片机——矩阵键盘

一、矩阵键盘原理图 我们发现: P17,P16,P15,P14控制行&#xff0c; P13,P12,P11,P10控制列。 所以我们如果要选择第四列&#xff0c;只需要把整个P1先给高电位1&#xff0c;再把P10给低电位0。 二、代码 P10xFF; P100; if(P170){Delay(20);while(P170);Delay(20);KeyNum…
阅读更多...
MySQL基础篇 - 多表查询

MySQL基础篇 - 多表查询

01 多表关系 【1】概念&#xff1a;项目开发中&#xff0c;在进行数据库表结构设计时&#xff0c;会根据业务需求及业务模块之间的关系&#xff0c;分析并设计表结构&#xff0c;由于业务之间相互关联&#xff0c;所以各表结构之间也存在着各种联系&#xff0c;基本上分为三种…
阅读更多...
数据结构-3.8.栈在括号匹配中的应用

数据结构-3.8.栈在括号匹配中的应用

一.括号匹配问题&#xff1a; 1.例一&#xff1a; 把左括号依次压入栈中&#xff0c;越往后压入栈的左括号越先被匹配即被弹出栈->先进后出&#xff0c;后进先出 2.例二&#xff1a; 当遇到左括号就压入栈中&#xff0c;当遇到右括号就把栈顶的左括号弹出&#xff0c;检查…
阅读更多...
void类型

void类型

编程语言中的void类型是一种特殊的数据类型&#xff0c;它表示不存在任何值。void, 无或者空类型。大部分编程语言支持void, 用做函数无返回值类型。最早ALGOL 68引入void类型。 void的特别使用 经典C缺乏void类型&#xff0c;函数可以不指定返回值&#xff0c;默认是整型int.…
阅读更多...
MacOS多桌面调度快捷键

MacOS多桌面调度快捷键

单桌面调度快捷键 可能是我用着妙控鼠标用着不习惯&#xff0c;所以追求快捷键操作&#xff0c;看起来也比较酷。而且在Windows上&#xff0c;我基本不使用多桌面&#xff0c;但是看着同事用Mac的多桌面用的飞起&#xff0c;炫酷程度不亚于win7的Windows键Tab。在不使用多桌面的…
阅读更多...
最新文章

Copyright @ 2022~2023