C++内存池

　　内存池是一种内存分配方式。通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片。并由于频繁的分配和回收内存会降低性能，我们都知道，对象的构造和析构都是要花费时间的。

　　内存池也是一种对象池，我们在使用内存对象之前，先申请分配一定数量的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。当不需要此内存时，重新将此内存放入预分配的内存块中，以待下次利用。这样合理的分配回收内存使得内存分配效率得到提升。

　　我们先看一个类。

 class Rational
 {
 public:
     Rational(int a = , int b = ) :m(a), n(b)
     {
     }
 private:

     int m;
     int n;
 };

　　为了测试频繁的分配和回收此类对象我们写一个测试代码.

 #include "stdafx.h"
 #include <iostream>
 #include <ctime>

 using std::cout;
 using std::cin;
 using std::endl;
 using std::minus;

 #define R_SIZE 1000

 int _tmain(int argc, _TCHAR* argv[])
 {
     Rational *array[R_SIZE];
     double ft = .0f;
     double st = .0f;

     ft = clock();
     for (int i = ; i < ; ++i)
     {
         for (int j = ; j < R_SIZE; ++j)
         {
             array[j] = new Rational;
         }
         for (int j = ; j < R_SIZE; ++j)
         {
             delete array[j];
         }

     }
     st = clock();

     cout << minus<double>()(st, ft) << endl;

     cin.get();

     return ;
 }

　　这样我们对Rational对象进行了100万次的对象分配和回收操作。这个代码在我的电脑上大概需要4890ms的执行时间

aaarticlea/png;base64,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" alt="" />，

这是我们使用默认的内存管理器分配和回收。显然，如此频繁的分配以及回收会频繁的触发对象构造和析构函数，势必降低程序的运行。这就是好比我们要装水，我们没装一桶水都要去买水桶，用完了就卖出去，用到的时候再去买。这样不仅费时费力，而且还降低了我们的装水的效率。那我们要是买来适量是水桶，我们要用的时候拿出来用，不用的时候放回去，不够时再去买，这样省了我们不少的时间。这就是我们的内存池思想。我们现在写一个专用的Rational内存管理器。

　　我们声明一个NextOnFreeList类来连接空闲列表的相邻对象。

 class NextOnFreeList
 {
 public:
     NextOnFreeList *next;
 };

class RationalMemPool
{
public:
    RationalMemPool(int a = , int b = ) :m(a), n(b)
    {
    }

    /*
     *    重载new操作，如果对象链表中没有空闲将重新分配。
     *    如果有空闲则从头部取出一个返回，并把空闲列表下移。
     */
    inline void *operator new(size_t _sz)
    {
        if (freeList == nullptr)
        {
            expandTheFreeList();
        }

        NextOnFreeList *head = freeList;

        freeList = head->next;

        return head;
    }

    /*
     *    重载delete操作，将对象放回预分配链表中
     */
    inline void operator delete(void* _doomed, size_t _sz)
    {
        NextOnFreeList *head = static_cast<NextOnFreeList*>(_doomed);

        head->next = freeList;

        freeList = head;
    }

    static void newMemPool(){ expandTheFreeList(); }
    static void deleteMemPool();

private:
    static void expandTheFreeList();
    enum{ EXPANSION =  };        //预分配对象数量

    int m;
    int n;

    static NextOnFreeList *freeList;    //空闲链表指针
};

NextOnFreeList * RationalMemPool::freeList = nullptr;

/*
 *    使用完销毁对象
 */
void RationalMemPool::deleteMemPool()
{
    NextOnFreeList *nextPtr;

    for (nextPtr = freeList; nextPtr != nullptr; nextPtr = freeList)
    {
        freeList = freeList->next;
        delete[] nextPtr;
    }
}

/*
 *    事先分配一定数量的对象
 */
void RationalMemPool::expandTheFreeList()
{
    size_t size = (sizeof(RationalMemPool) > sizeof(NextOnFreeList*)) ?
        sizeof(RationalMemPool) : sizeof(NextOnFreeList*);

    NextOnFreeList *runner = reinterpret_cast<NextOnFreeList *>(new char[size]);

    freeList = runner;

    for (int i = ; i < EXPANSION; ++i)
    {
        runner->next = reinterpret_cast<NextOnFreeList *>(new char[size]);

        runner = runner->next;
    }

    runner->next = ;
}

　　重新设计了Rational的内存分配策略后，我们再来看看测试代码的运行时间。

 #include "stdafx.h"
 #include <iostream>
 #include <ctime>

 using std::cout;
 using std::cin;
 using std::endl;
 using std::minus;

 #define R_SIZE 1000

 int _tmain(int argc, _TCHAR* argv[])
 {
     double ft = .0f;
     double st = .0f;
     RationalMemPool *array[R_SIZE];

     ft = clock();
     RationalMemPool::newMemPool();
     for (int i = ; i < ; ++i)
     {
         for (int j = ; j < R_SIZE; ++j)
         {
             array[j] = new RationalMemPool(j);
         }
         for (int j = ; j < R_SIZE; ++j)
         {
             delete array[j];
         }
     }
     RationalMemPool::deleteMemPool();
     st = clock();

     cout << minus<double>()(st, ft) << endl;

     cin.get();

     return ;
 }

测试代码在我电脑上运行需要的时间为40ms

aaarticlea/png;base64,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" alt="" />

我们可以看到运行效率不只是一个级别。

参考《提高C++性能的编程技术》

/********************************2016-11-25更新****************************************/

　　我们在以上已经封装了一个专用的内存管理类了。那要是我们想让一个新类拥有类似的功能是不是也是要为这个类实现上面的成员呢，答案是的，不过我们可以通过一些技巧来完成，比如我们建立一个拥有这些能力的基类，再继承这个基类以拥有这些功能就可以了。

 typedef unsigned char UCHAR;

 template <class T, int BLOCK_NUM = >
 class GenericMP
 {
 public:
     static void *operator new(size_t allocLen)
     {
         assert(sizeof(T) == allocLen);
         if (!m_NewPointer)
             MyAlloc();
         UCHAR *rp = m_NewPointer;
         m_NewPointer = *reinterpret_cast<UCHAR**>(rp); //由于头4个字节被“强行”解释为指向下一内存块的指针，这里m_NewPointer就指向了下一个内存块，以备下次分配使用。
         return rp;
     }
     static void operator delete(void *dp)
     {
         *reinterpret_cast<UCHAR**>(dp) = m_NewPointer;
         m_NewPointer = static_cast<UCHAR*>(dp);
     }

     static void deletePool()
     {
         UCHAR *p = m_NewPointer;

         delete[] m_NewPointer;
         m_NewPointer = nullptr;
     }
 private:
     static void MyAlloc()
     {
         m_NewPointer = new UCHAR[sizeof(T)* BLOCK_NUM];

         memset(m_NewPointer, , sizeof(T)* BLOCK_NUM);

         cout << sizeof(T)* BLOCK_NUM << endl;
         UCHAR **cur = reinterpret_cast<UCHAR**>(m_NewPointer); //强制转型为双指针，这将改变每个内存块头4个字节的含义。
         UCHAR *next = m_NewPointer;
         for (size_t i = ; i < BLOCK_NUM - ; ++i)
         {
             next += sizeof(T);
             *cur = next;
             cur = reinterpret_cast<UCHAR**>(next); //这样，所分配的每个内存块的头4个字节就被“强行“解释为指向下一个内存块的指针， 即形成了内存块的链表结构。
         }
         *cur = ;
     }
     static UCHAR *m_NewPointer;
 protected:
     ~GenericMP()
     {
     }
 };
 template<class T, int BLOCK_NUM >
 UCHAR *GenericMP<T, BLOCK_NUM >::m_NewPointer;

 //////////////////////////////////////////////////////////////////////////
 class ExpMP : public GenericMP<ExpMP>
 {
 public:
     UCHAR a[];
 };
 //////////////////////////////////////////////////////////////////////////
 int _tmain(int argc, _TCHAR* argv[])
 {
     ExpMP *aMP1 = new ExpMP();
     memcpy_s(aMP1->a + , , "aMP1", strlen("aMP1"));    //由于头四个字节我们已经用来存放下一个对象的指针了，所以存在数据要从4个字节以后开始

     ExpMP *aMP2 = new ExpMP();
     memcpy_s(aMP2->a + , , "aMP2", strlen("aMP2"));

     delete aMP1;
     delete aMP1;

     ExpMP::deletePool();

     cin.get();

     return ;
 }