单线程内存池

频繁的分配和回收内存会严重的降低程序的性能。性能降低的原因在于默认的内存管理器是通用的，应用程序会以特定的方式使用内存，并且为不需要的功能付出代价，比方说单线程运行的程序不需要为处理多线程的部分付出代价。设计专用的内存管理器可以解决这个问题，设计时应该至少想到以下两个方面：

• 大小
• 并发

从大小角度：

• 固定大小：分配固定大小内存块的内存管理器
• 可变大小：分配任意大小内存块的内存管理器。所请求分配的大小实现是未知的。

从并发的角度：

• 单线程：内存的管理局限在一个线程内。内存被一个线程使用，并且不越出该线程的界限。这种内存管理器不涉及相互访问的多线程。
• 多线程：内存管理器被多个线程并发地使用。这种实现需要包含互斥执行的代码段。无论什么时候，只能有一个线程在执行一个代码段。

专用Rational内存管理器

class NextOnFreeList {
    public:
        NextOnFreelist *next;
}
class Rational {
    public:
        Rational (int a = 0, int b = 1) : n(a), d(b) {}
        inline void *operator new(size_t size);
        inline void operator delete(void *doomed, size_t size);
        static void newMemPool() {expandTheFreeList();}
        static void deleteMemPool();
    private:
        static NextonFreeList *freeList; //Rational对象的空闲列表
        static void expandTheFreeList();
        enum {EXPANSION_SIZE = 32};
        int n;
        int d;
}
inline
void* Rational::operator new(size_t size)
{
    if (0 == freeList) { //如果列表为空，则将其填满
        expandTheFreeList();
    }
    NextOnFreeList *head = freeList;
    freeList = head->next;
    return head;
}
//Rational
inline
void Rational::operator delete(void *doomed, size_t size)
{
    NextOnFreeList *head = static_cast<NextOnFreeList *>doomed;
    head->next = freeList;
    freeList = head;
}
void Rational::expandTheFreeList()
{
    size_t size = (sizeof(Rational) > sizeof(NextOnFreeList *)) ? 
        sizeof(Rational) : sizeof(NextOnFreeList *);
    NextOnFreeList *runner = static_cast<NextOnFreelist *> new char[size];
    freeList = runner;
    for(int i = 0; i < EXPANSION_SIZE; i++) {
        runner->next = 
            static_cast<NextOnFreeList *> new char [size];
        runner = runner->next;
    }
    runner->next = 0;
}
void Rational::deleteMemPool()
{
    NextOnFreeList *nextPtr;
    for (nextPtr = freeList; nextPtr != NULL; nextPtr = freeList) {
        freeList = freeList->next;
        delete []nextPtr;
    }
}

固定大小对象的内存池