多进程编程多用在并发服务器的编写上，当收到一个请求时，服务器新建一个进程处理请求，同时继续监听。为了提高响应速度，服务器采用进程池的方法，在初始化阶段创建一个进程池，池中有许多预创建的进程，当请求到达时，只需从池中分配出来一个进程即可；当进程不够用时，进程池将再次创建一批进程。类似的方法可以用在内存分配上。
C++中，创建一个复杂的对象需要几十条指令，包括函数调用的代价(寄存器值得保存和恢复)，以及构造或复制构造函数体的执行代价，甚至动态分配内存的代价。尤其是，在不重载new和delete运算符时，由于C++的new和delete是通用的，其中甚至提供了支持多线程编程的同步机制，对于单线程编程将带来不必要的运算。
如果需要创建的对象的个数是动态变化的，可以首先预开辟一片较大的内存，每次要创建对象时将一段内存分配出去。为了提高创建对象的速度，内存池应满足如下设计要求：
1，一定的通用性，适用于多类型，而不局限于某个类；
2，一定的灵活性，可以在不对类作过多修改的前提下，将内存池机制轻易融入到原代码中；
3，可能要满足多线程的要求。
4，通用性、灵活性视实际情况而定，不必完美。
一、专用内存池
先从专用内存池开始，假设要不断创建Complex (复数)类，下面的代码实现了针对Complex对象的内存池。看过《Efficient C++》(不是Effective C++)中关于内存池的内容后，笔者打算自己耍一耍：
#include #include
using namespacestd;classSimpleComplex
{doublere;doubleim;public:explicit SimpleComplex(const double r = 0.0, const double i = 0.0):re(r), im(i) {}
};classNext
{public:
Next*next;
};classComplex
{static Next *freelist;enum {EXPAND_SIZE = 2};doublere;doubleim;static voidexpand()
{
Next* p = (Next *) (new char [sizeof(Complex)]);
freelist=p;for(int i=1; i
{
p->next = (Next *) new char [sizeof(Complex)];
p= p->next;
}
p->next = 0;
}public:explicit Complex(const double r = 0.0, const double i = 0.0):re(r), im(i) {}
inlinevoid * operator new(size_t size)
{if (0 ==freelist)
expand();
Next* p =freelist;
freelist= freelist->next;returnp;
}
inlinevoid operator delete(void *ptr, size_t size)
{
((Next*)ptr)->next =freelist;
freelist= (Next *)ptr;
}static voidnewPool()
{
expand();
}static voiddeletePool()
{
Next* p =freelist;while(p)
{
freelist= freelist->next;
delete [] p;
p=freelist;
}
}
};
Next* Complex::freelist = 0;
main()
{double from = time(0);
Complex*c[100];for (int i=0; i<1000000; i++)
{for (int j=0; j<100; j++)
c[j]= newComplex();for (int j=0; j<100; j++)
delete c[j];
}
Complex::deletePool();double to = time(0);
cout<
SimpleComplex*s[100];for (int i=0; i<1000000; i++)
{for (int j=0; j<100; j++)
s[j]= newSimpleComplex();for (int j=0; j<100; j++)
delete s[j];
}
to= time(0);
cout<
}注意虽然有一个class next，但总体上看所有的内存块却并不组成链表。这里，内存是这么分配的：任何时刻freelist指向可用的内存块链表的头部，即第一个可用的内存块(单不足时，freelist指向NULL)。假设分别执行下面的语句：
p1 = newComplex ();
p2= newComplex ();
p3= newComplex ();
p4= newComplex ();
delete p2;
delete p4;
p5= new Complex ();过程是这样的。Complex专属内存池在初始时刻不分配任何空间。给p1创建对象时，由于freelist指向NULL，先按照EXPAND_SIZE的值，开辟EXPAND_SIZE * sizeof(Complex)大小的内存。此时：
freelist -> [ next] -> [ next] -> NULL随后将freelist指向的内存块分配给p1：
p1-> [ next] freelist-> [ next] -> NULL随后将freelist指向的内存块分配给p2：
p1-> [ next] p2-> [ next] freelist -> NULL随后为p3分配内存，在此之前再次执行expand() ：
p1-> [ next] p2 -> [ next] p3 -> [ next] freelist -> [ next] -> NULL随后将freelist指向的内存块分配给p4：
p1-> [ next] p2 -> [ next] p3 -> [ next] p4 -> [ next] freelist-> NULL随后释放p2，内存池这时需要将p2的空间回收再利用，于是把p2的空间插入到freelist指向的链的前端：
p1-> [ next] p3 -> [ next] p4 -> [ next] freelist -> [(p2) next] -> NULL随后释放p2，内存池这时需要将p2的空间回收再利用，于是把p2的空间插入到freelist指向的链的前端：
p1-> [ next] p3 -> [ next] freelist -> [(p4) next] -> [(p2) next] -> NULL这样为p5开辟内存时，只需将原p4的内存给p5即可。
虽然池中的内存块不是以链表形式存在，当上述代码保证每个内存块都有一个指针变量指向它，最终在销毁时可以正常销毁。当然，如果仅仅写道
new Complex ();这时创建的内存块就成了碎片，就算对于通用的new delete操作符而言，这样的碎片也是无可奈何的。
注意，内存池并不实现像Java和C#这样自动回收内存的复杂机制，毕竟像JVM这样以插入一层虚拟机并牺牲一定的性能为代价，召唤出“上帝视角”后，什么事都能干成，因为一切的一切都被一个上帝管着，区区未指向的内存块的回收就不在话下了，你找不到它，上帝找得到。“BB is watching you!”(老大哥在看着你！)
2, 通用固定大小内存池
上述内存池的实现嵌入在Complex代码中，只具备最低级的代码重用性(即复制粘贴方式的重用)。下面这个内存池通过模板的方式，适用于所有的单一类型。
#include #include
classMemPoolNext
{public: MemPoolNext *next;
};
template
classMemPool
{enum {EXPAND_SIZE = 16};static MemPoolNext *freelist;static voidexpand()
{
size_t size= sizeof(T);if(size < sizeof(void *))
size= sizeof(void *);
MemPoolNext* p = (MemPoolNext *) new char[size];
freelist=p;for(int i=1; inext)
p->next = (MemPoolNext *) new char[size];
p->next = 0;
}public:static void *alloc (size_t)
{if(0 ==freelist)
expand();void * p =freelist;
freelist= freelist->next;returnp;
}static void free (void *p, size_t)
{
((MemPoolNext*) p)->next =freelist;
freelist= (MemPoolNext *) p;
}static voiddeletepool()
{
MemPoolNext* p =freelist;while( p!=0)
{
freelist= p->next;
delete p;
p=freelist;
}
}
};
templateMemPoolNext* MemPool::freelist = 0;classComplex
{public:doublere;doubleim;explicit Complex(double r = 0., double i = 0.): re(r), im(i){}
inlinestatic void * operator new(size_t s)
{return MemPool::alloc(s);
}
inlinestatic void operator delete (void *p, size_t s)
{
MemPool::free(p, s);
}
inlinestatic voiddeletepool()
{
MemPool::deletepool();
}
};
main()
{double from = time(0);
Complex* c[100];for (int i=0; i<1000000; i++)
{for(int j=0; j<100; j++)
c[j]= newComplex(j, j);for(int j=0; j<100; j++)
delete c[j];
}
Complex::deletepool();double to = time(0);
printf("%f\n", to-from);
}实际上很简单，无非是将原来写在Complex中用来管理内存的代码封装成了一个新的类MemPool。
三，多线程固定大小内存池
代码略，只需在临界区前后加上锁即可，最常用的锁是pthread_mutex_lock(信号量锁)。
四，多线程非固定大小内存池
此时，一个内存池内的对象已不局限于单一的类，而是能够同时包容不同类型的对象。代码略，只需在开辟和回收内存时，考虑当前可用的内存大小和已分配的内存大小即可。
