boost库内存池使用

内存池(Memory Pool)是一种内存分配方式。        通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。

内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。

 

Pool分配是一种分配内存方法，用于快速分配同样大小的内存块，
    尤其是反复分配/释放同样大小的内存块的情况。

使用pool内存池主要有以下两个优点：

　　1.能够有效地管理许多小型对象的分配和释放工作，避免了自己去管理内存而产生的内存碎片和效率低下问题。

　　2. 告别程序内存泄漏的烦恼，pool库会在内部对内存自动进行管理，避免了程序员一不小心而造成的内存泄漏问题。

 

1. pool

    快速分配小块内存，如果pool无法提供小块内存给用户，返回0。

    Example:

    void func()
    {
      boost::pool<> p(sizeof(int));
                      ^^^^^^^^^^^
                      指定每次分配的块的大小
      for (int i = 0; i < 10000; ++i)
      {
        int * const t = p.malloc();
                        pool分配指定大小的内存块；需要的时候，pool会向系统
                        申请大块内存。
        ... // Do something with t; don't take the time to free() it
        p.free( t );
        // 释放内存块，交还给pool，不是返回给系统。
      }

      pool的析构函数会释放所有从系统申请到的内存。

 

2. object_pool   

 

    与pool的区别在于：pool需要指定每次分配的块的大小，object_pool需要指定
    每次分配的对象的类型。

    Example:

    struct X { ... }; // has destructor with side-effects

    void func()
    {
      boost::object_pool<X> p;
                         ^
      for (int i = 0; i < 10000; ++i)
      {
        X * const t = p.malloc();
                      注意；X的构造函数不会被调用，仅仅是分配大小为sizeof(X)
                      的内存块。如果需要调用构造函数（像new一样），应该调用
                      construct。比如：
                      X * const t = p.construct();
        ...
      }
    }

 

3. singleton_pool

    与pool用法一样。不同的是：可以定义多个pool类型的object，都是分配同样
    大小的内存块；singleton_pool提供静态成员方法分配内存，不用定义object。

    Example:

    struct MyPoolTag { };

    typedef boost::singleton_pool<MyPoolTag, sizeof(int)> my_pool;
    void func()
    {
      for (int i = 0; i < 10000; ++i)
      {
        int * const t = my_pool::malloc();
                        // ^^^^^^^^^
                        // 和pool不一样。
        ...
      }

      my_pool::purge_memory();
      // 释放my_pool申请的内存。
    }

 

4. pool_alloc

    基于singleton_pool实现，提供allocator（用于STL等）。

    Example:

    void func()
    {
      std::vector<int, boost::pool_allocator<int> > v;
      for (int i = 0; i < 10000; ++i)
        v.push_back(13);
    }

    需要的话，必须自己显式地调用
    boost::singleton_pool<boost::pool_allocator_tag, sizeof(int)>::release_memory()
    把allocator分配的内存返回系统。

实现原理

    pool每次向系统申请一大块内存，然后分成同样大小的多个小块，
    形成链表连接起来。每次分配的时候，从链表中取出头上一块，提
    供给用户。链表为空的时候，pool继续向系统申请大块内存。
    一个小问题：在pool的实现中，在申请到大块内存后，马上把它分
    成小块形成链表。这个过程开销比较大。即你需要分配一小块内存
    时，却需要生成一个大的链表。用如下代码测试:

boost::pool<> mem_pool(16);

for(i = 0; i < NPASS; i++) {
     period = clock();
  for(n = 0; n < NITEM; n++) {
   array_ptr[n] = (int *)mem_pool.malloc();
  }
  for(n = 0; n < NITEM; n++) {
   mem_pool.free(array_ptr[n]);
  }
     period = clock() - period;
     printf("pool<>  : period = %5d ms", period);
}

    可以发现，第一遍花的时间明显多于后面的。

    而且在pool的使用过程中如果不是恰好把链表中所有的小块都用上
    的话，在链表中最后的一些小块会始终用不上。把这些小块加入链
    表是多余的。虽然这个开销可能很小:)