C++对象池的实现与应用

一、什么是对象池

对象池是一种用于管理对象缓存的数据结构，用于保存多个已分配的对象，以便在需要时可以快速重用它们，从而减少了对象的动态分配和释放的开销。

C++的对象池通常用于管理相对较小的可重复使用的对象，如单例模式的对象、线程池的任务对象、内存池中的对象、连接池中的连接对象等一些生命周期比较长的对象。

二、对象池的实现

1.对象池的设计思路

一般的对象池是由一个数组和一个标志位组成的，数组用于保存对象的指针，标志位指示该对象是否空闲可用。

对象池通常可以完成以下操作：

1. 对象池的初始化。

2. 从对象池中分配出一个对象。

3. 归还操作，将对象放回对象池中。

4. 清理对象池，销毁对象。

2.对象池的实现代码

template
class ObjectPool
{
public:
    ObjectPool(int maxSize = 1024) : m_maxSize(maxSize), m_allocIdx(0), m_freeIdx(0)
    {
        m_pArray = new T[maxSize];
        m_pFreeList = new int[maxSize];

        for(int i = 0; i < maxSize; i++)
        {
            m_pFreeList[i] = i;
        }
    }

    ~ObjectPool()
    {
        delete[] m_pArray;
        delete[] m_pFreeList;
    }

    T* allocate()
    {
        if(m_freeList.empty())
        {
            printf("ObjectPool error! no available object to allocate!");
            return NULL;
        }

        int idx = m_freeList[m_freeIdx++];
        T* pObj = new(m_pArray + idx) T(); //直接调用构造函数
        m_allocList.insert(std::make_pair(pObj, idx)); //插入到map中记录分配情况
        return pObj;
    }

    void deallocate(T* pObj)
    {
        typename std::map
   ::iterator it = m_allocList.find(pObj);
        if(it == m_allocList.end())
        {
            printf("ObjectPool error! freeing invalid object! ");
            return;
        }

        pObj->~T(); //调用析构函数
        m_freeList[--m_freeIdx] = it->second;
        m_allocList.erase(it);
    }

private:
    T* m_pArray;
    int m_maxSize;
    int m_allocIdx; //分配指针
    int m_freeIdx; //空闲指针

    std::vector
     m_freeList;
    std::map
      m_allocList;
};

     
    
   
  

三、对象池的应用

1.使用对象池管理连接

在TCP服务器中，每个连接会占用一个套接字资源，如果频繁申请和释放套接字对象，会给系统带来很大的负担。使用对象池管理连接可以避免频繁的套接字对象申请和释放，提高系统的性能。

#include 
#include "ObjectPool.h"

class Connection
{
public:
    void setSocket(int sock)
    {
        m_sock = sock;
    }

    int getSocket() const
    {
        return m_sock;
    }

private:
    int m_sock;
};

int main()
{
    ObjectPool
    pool(1000);

    Connection* conn = pool.allocate();
    conn->setSocket(1001);
    std::cout << "socket: " << conn->getSocket() << std::endl;

    pool.deallocate(conn);
    std::cout << "socket: " << conn->getSocket() << std::endl;

    return 0;
}

   
  

2.使用对象池管理任务

在使用线程池时，为了避免频繁创建和销毁任务，可以使用对象池管理任务对象，从而提高系统的性能。

#include 
#include "ObjectPool.h"

class Task
{
public:
    void run()
    {
        std::cout << "Task is running!" << std::endl;
    }
};

int main()
{
    ObjectPool
    pool(1000);

    Task* task = pool.allocate();
    task->run();

    pool.deallocate(task);
    task->run();

    return 0;
}

   
  

3.使用对象池管理内存块

在内存池的实现中，为了减少内存分配和释放的开销，通常使用对象池来管理内存块。内存块的大小是固定的，每个内存块使用标记位标记是否正在使用，如果该块没有被占用，则将其放置到内存池的空闲链表中。

#include 
#include "ObjectPool.h"

class MemoryBlock
{
public:
    char m_data[1024];
};

int main()
{
    ObjectPool
    pool(1000);

    MemoryBlock* block = pool.allocate();
    std::cout << "MemoryBlock is allocated!" << std::endl;

    pool.deallocate(block);
    std::cout << "MemoryBlock is deallocated" << std::endl;

    return 0;
}

   
  

四、总结

对象池是一种用于管理对象缓存的数据结构，可以在需要时快速重用对象，从而减少了对象的动态分配和释放的开销。C++的对象池通常用于管理相对较小的可重复使用的对象。本文讲解了对象池的实现思路和具体实现代码，并以连接、任务和内存块为例，阐述了对象池的应用。