C++内存池

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

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

　　我们先看一个类。

class Rational
{
public:
    Rational(int a = 0, int b = 1) :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 = 0; i < 500; ++i)
    {
        for (int j = 0; j < R_SIZE; ++j)
        {
            array[j] = new Rational;
        }
        for (int j = 0; j < R_SIZE; ++j)
        {
            delete array[j];
        }

    }
    st = clock();

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

    cin.get();

    return 0;
}

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

，

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

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

class NextOnFreeList
{
public:
    NextOnFreeList *next;
};

class RationalMemPool
{
public:
    RationalMemPool(int a = 0, int b = 1) :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 = 50 };        //预分配对象数量

    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 = 0; i < EXPANSION; ++i)
    {
        runner->next = reinterpret_cast<NextOnFreeList *>(new char[size]);

        runner = runner->next;
    }

    runner->next = 0;
}

　　重新设计了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 = 0; i < 500; ++i)
    {
        for (int j = 0; j < R_SIZE; ++j)
        {
            array[j] = new RationalMemPool(j);
        }
        for (int j = 0; j < R_SIZE; ++j)
        {
            delete array[j];
        }
    }
    RationalMemPool::deleteMemPool();
    st = clock();

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

    cin.get();

    return 0;
}

 

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

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

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

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

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

typedef unsigned char UCHAR;

template <class T, int BLOCK_NUM = 5>
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, 0, 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 = 0; i < BLOCK_NUM - 1; ++i)
        {
            next += sizeof(T);
            *cur = next;
            cur = reinterpret_cast<UCHAR**>(next); //这样，所分配的每个内存块的头4个字节就被“强行“解释为指向下一个内存块的指针， 即形成了内存块的链表结构。
        }
        *cur = 0;
    }
    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[10];
};
//////////////////////////////////////////////////////////////////////////
int _tmain(int argc, _TCHAR* argv[])
{
    ExpMP *aMP1 = new ExpMP();
    memcpy_s(aMP1->a + 4, 10, "aMP1", strlen("aMP1"));    //由于头四个字节我们已经用来存放下一个对象的指针了，所以存在数据要从4个字节以后开始

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

    delete aMP1;
    delete aMP1;

    ExpMP::deletePool();


    cin.get();

    return 0;
}