Chinaunix首页 | 论坛 | 博客

http://chinchao.xyz

首页　| 　博文目录　| 　关于我

qinchaowhut

  • 博客访问： 360492
  • 博文数量： 60
  • 博客积分： 15
  • 博客等级： 民兵
  • 技术积分： 1138
  • 用 户 组： 普通用户
  • 注册时间： 2012-03-20 16:18
个人简介

最多140个字

文章分类

全部博文（60）

文章存档

2016年（1）

2015年（34）

2014年（25）

我的朋友
最近访客
推荐博文
相关博文
对象大小固定-内存池

分类： C/C++

2015-04-03 16:41:05


  1. #include<iostream>
  2. using namespace std;

  4. template<class T>
  5. class FreeList
  6. {
  7.     private:
  8.         FreeList<T>* next;//空闲链表的下一个元素
  9.         enum{EXPANSION_SIZE=20};//如果空闲链表为空，则按该SIZE扩展它
  10.         void expandTheFreeList(int initSize=EXPANSION_SIZE)//添加空闲元素到空闲列表
  11.         {
  12.             int size=sizeof(T)>sizeof(FreeList<T>*)? sizeof(T):sizeof(FreeList*);
  13.             FreeList<T> *ptr=(FreeList<T>*)new char[size];
  14.             next=ptr;
  15.             for(int i=0;i<initSize;i++)
  16.             {
  17.                 ptr->next=(FreeList<T>*)new char[size];
  18.                 ptr=ptr->next;
  19.             }
  20.             ptr->next=NULL;
  21.         }
  22.     public:
  23.         FreeList(int size=EXPANSION_SIZE)
  24.         {
  25.             expandTheFreeList(size);
  26.         }
  27.         ~FreeList()
  28.         {
  29.             FreeList<T> *ptr=next;
  30.             for(ptr=next;ptr!=NULL;ptr=next)
  31.             {
  32.                 next=next->next;
  33.                 delete[] (char*)ptr;
  34.             }
  35.         }
  36.         void *alloc(int size)//从空闲列表中分配头节点
  37.         {
  38.             if(next==NULL)
  39.                 expandTheFreeList();
  40.             FreeList<T> *head=next;
  41.             next=head->next;
  42.             return head;
  43.         }
  44.         void free(void *element)//释放T元素所占的空间
  45.         {
  46.             FreeList<T> *head=(FreeList<T>*)element;
  47.             head->next=next;
  48.             next=head;
  49.         }

  51. };

  53. class Rational{
  54. private:
  55.     int a;
  56.     int b;
  57.     static FreeList<Rational> *pool;
  58. public:
  59.     Rational(int a=0,int b=1)
  60.     {
  61.         Rational::a=a;
  62.         Rational::b=b;
  63.     }
  64.     void *operator new(size_t size)
  65.     {
  66.         return pool->alloc(size);
  67.     }
  68.     void operator delete(void *ptr,size_t size)
  69.     {
  70.         pool->free(ptr);
  71.     }
  72.     static void newPool()
  73.     {
  74.         pool=new FreeList<Rational>;
  75.     }
  76.     static void deletePool()
  77.     {
  78.         delete pool;
  79.     }
  80.     void show()
  81.     {
  82.         cout<<a<<' '<<b<<endl;
  83.     }
  84. };
  85. FreeList<Rational>* Rational::pool=NULL;

  86.
  87. int main()
  88. {
  89.     Rational::newPool();

  90.
  91.     for (int i=0; i<5; ++i)
  92.     {
  93.         Rational* ptr[1000];
  94.         for (int j=0; j<10; ++j)
  95.         {
  96.             ptr[j] = new Rational(i,j);
  97.             ptr[j]->show();
  98.         }
  99.         for (int k=0; k<10; ++k)
  100.         {
  101.             delete ptr[k];
  102.         }
  103.     }

  105.     Rational::deletePool();
  106. }
    1. //多线程版本
    2. #include<iostream>
    3. #include<pthread.h>
    4. #include<unistd.h>
    5. using namespace std;


    8. template<class T>
    9. class FreeList
    10. {
    11.     private:
    12.         FreeList<T>* next;//空闲链表的下一个元素
    13.         enum{EXPANSION_SIZE=20};//如果空闲链表为空，则按该SIZE扩展它
    14.         void expandTheFreeList(int initSize=EXPANSION_SIZE)//添加空闲元素到空闲列表
    15.         {
    16.             int size=sizeof(T)>sizeof(FreeList<T>*)? sizeof(T):sizeof(FreeList*);
    17.             FreeList<T> *ptr=(FreeList<T>*)new char[size];
    18.             next=ptr;
    19.             for(int i=0;i<initSize;i++)
    20.             {
    21.                 ptr->next=(FreeList<T>*)new char[size];
    22.                 ptr=ptr->next;
    23.             }
    24.             ptr->next=NULL;
    25.         }
    26.     public:
    27.         FreeList(int size=EXPANSION_SIZE)
    28.         {
    29.             expandTheFreeList(size);
    30.         }
    31.         ~FreeList()
    32.         {
    33.             FreeList<T> *ptr=next;
    34.             for(ptr=next;ptr!=NULL;ptr=next)
    35.             {
    36.                 next=next->next;
    37.                 delete[] (char*)ptr;
    38.             }
    39.         }
    40.         void *alloc(int size)//从空闲列表中分配头节点
    41.         {
    42.             if(next==NULL)
    43.                 expandTheFreeList();
    44.             FreeList<T> *head=next;
    45.             next=head->next;
    46.             return head;
    47.         }
    48.         void free(void *element)//释放T元素所占的空间
    49.         {
    50.             FreeList<T> *head=(FreeList<T>*)element;
    51.             head->next=next;
    52.             next=head;
    53.         }


    56. };


    59. template<class POOLTYPE, class LOCK>
    60. class MTMemoryPool
    61. {
    62. private:
    63. POOLTYPE pool;
    64. LOCK lockx;
    65. public:
    66. inline void *alloc(size_t size);
    67. inline void free(void *element);
    68. };
    69. template<class M,class L>
    70. inline void *MTMemoryPool<M,L>::alloc(size_t size)
    71. {
    72. void *mem;
    73. lockx.lock();
    74. mem=pool.alloc(size);
    75. lockx.unlock();
    76. return mem;
    77. };
    78. template<class M, class L>
    79. inline void MTMemoryPool<M,L>::free(void *dmd)
    80. {
    81. lockx.lock();
    82. pool.free(dmd);
    83. lockx.unlock();
    84. };


    87. class ABCLock
    88. {
    89. public:
    90. virtual ~ABCLock()
    91. {
    92. }
    93. virtual void lock()=0;
    94. virtual void unlock()=0;
    95. };


    98. class MutexLock:public ABCLock
    99. {
    100. private:
    101. pthread_mutex_t lockx;
    102. public:
    103. MutexLock()
    104. {
    105. pthread_mutex_init(&lockx,NULL);
    106. }
    107. ~MutexLock()
    108. {
    109. pthread_mutex_destroy(&lockx);
    110. }
    111. void lock()
    112. {
    113. pthread_mutex_lock(&lockx);
    114. }
    115. void unlock()
    116. {
    117. pthread_mutex_unlock(&lockx);
    118. }
    119. };


    122. class Rational{
    123. private:
    124.     int a;
    125.     int b;
    126.     static MTMemoryPool< FreeList<Rational>, MutexLock >* pool;//修改
    127. public:
    128.     Rational(int a=0,int b=1)
    129.     {
    130.         Rational::a=a;
    131.         Rational::b=b;
    132.     }
    133.     void *operator new(size_t size)
    134.     {
    135.         return pool->alloc(size);
    136.     }
    137.     void operator delete(void *ptr,size_t size)
    138.     {
    139.         pool->free(ptr);
    140.     }
    141.     static void newPool()
    142.     {
    143.         pool=new MTMemoryPool<FreeList<Rational>, MutexLock> ;//修改
    144.     }
    145.     static void deletePool()
    146.     {
    147.         delete pool;
    148.     }
    149.     void show()
    150.     {
    151.         cout<<a<<' '<<b<<endl;
    152.     }
    153. };
    154. MTMemoryPool<FreeList<Rational>, MutexLock>* Rational::pool=NULL;


    157. int main()
    158. {
    159.     Rational::newPool();


    162.     for (int i=0; i<5; ++i)
    163.     {
    164.         Rational* ptr[1000];
    165.         for (int j=0; j<10; ++j)
    166.         {
    167.             ptr[j] = new Rational(i,j);
    168.             ptr[j]->show();
    169.         }
    170.         for (int k=0; k<10; ++k)
    171.         {
    172.             delete ptr[k];
    173.         }
    174.     }


    177.     Rational::deletePool();
    178. }

阅读(2424) | 评论(0) | 转发(0) |
0

上一篇：链表快排

下一篇：chattr

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6