简述动态存储分配及malloc(),free()函数

（本文基于linux系统。）

首先说一下程序运行是的存储分配：

存储分配

这张是典型的C语言的存储分配图。动态存储分配主要涉及图中的堆区。堆是无结构的连续的存储区域。当调用malloc()函数时，存储分配器从堆中找一块合适大小的连续的内存空间返回给程序。

malloc和free函数的原型如下：

void * malloc(size_t size)

void free(void* ptr)

这两个函数的使用就不在赘述了。

其实说白了，malloc和free函数就是负责对堆区的存储空间进行管理。既然要对堆区进行管理，而堆区又是无结构的，因此需要一个（运行库）自定义的结构来对堆区进行管理。

既然是对存储空间的管理，那么必然要面对两个问题--------存储空间的利用率和运行的效率。

首先是存储空间的利用率，这里面牵扯到一个概念--------碎片（fragmentation）。碎片又分为两种：内碎片和外碎片。

1. 内碎片是指分配给程序的存储空间没有用完，有一部分是闲着的，这部分空间成为内碎片。
2. 外碎片是虽然还有空间可以分配，但是这些空间都是不连续的小块，不能满足程序对连续存储的要求，因此无法分配给程序使用。这些不能满足程序要求的小的可以分配的存储空间成为外碎片。

对内碎片的处理很容易，只要保证分配的空间和使用的空间一样大小就行了。这主要是靠写程序的程序员们估算好自己所需要的空 间。（为了保证分配的空间是块对齐，也就是双字对齐，分配器可能返回比实际申请的空间多出一个字节的空间。但相对于目前庞大的内存空间，这一个字节已经微 不足道了。但是如果程序申请大量的小块内存，这个问题还是要考虑的。。。比如：大量申请3个字节的空间，为了对齐，返回四个字节。这就导致四分之一的空间 浪费。）

对于外碎片，处理的方法说起来很简单--------合并。但说归说，真正合并的时候就很困难。如果空闲的碎片是连续的， 那合并很简答。如果碎片不连续，这就很麻烦了。可以对内存进行紧缩，但这样效率很难保证。操作系统对内存进行管理是，大都使用分页，分段或段页式的管理来 减少外碎片。如果在程序中对堆区的管理再引入复杂的外碎片处理措施，不但运行效率低，而且多此一举。。。所以，当在处理合并的时候，基本都只考虑相邻的空 闲块。

关于效率的问题，后面会详细说明。

如果空间无限大，那么malloc就可以不断的分配新的空间给程序，而free函数则什么都不要做。因此，使用过的空间将直接丢弃而不再重用。这样 malloc和free函数即简单，效率也高。但是！存储空间是有限的。理论上在 32-位 x86 系统上，进程可用的最大空间是4G（由地址宽度决定）。但是不可能直接给程序分配4G的空间。。。因此，程序一开始运行的时候，堆区都有一个默认的大小。 这样，在程序运行的过程中，可能出现堆区中的空间都耗尽的情况（也可能没有耗尽，但都是小的碎片）。因此，就要给程序的堆区扩容，也就是让操 作系统给程序分配更多的空间，术语叫把空间映射到程序的堆区中。在这里有一个概念，叫系统中断点或当前中断点，也就是被映射的内存的边界（最后一个有效地 址），也就是堆顶。

对堆区进行扩容，可调用下面的两个系统调用：

• brk： int brk(void *end_data_segment) 是一个非常简单的系统调用。  brk() 只是简单地将系统中断点设置为end_data_segment，向进程添加内存或者从进程取走内存。
• mmap： mmap()，或者说是“内存映像”，类似于 brk()，但是更为灵活。首先，它可以映射任何位置的内存， 而不单单只局限于进程。其次，它不仅可以将虚拟地址映射到物理的 RAM 或者 swap，它还可以将 它们映射到文件和文件位置，这样，读写内存将对文件中的数据进行读写。不过，在这里，我们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所做的事情与mmap() 相反。

还有一个叫sbrk的系统调用void *sbrk(intptr_t increment)。sbrk()增加increment字节的内存到进程的堆区。而其返回的是旧的系统中断点，而不是新的。

下面说一下一种叫做隐式空闲链表的管理堆区的方法。堆块的格式如下：

-------------------------------------------------------------------

|         int         available        /*是否空闲*/                                |

|         int         size                   /*此块的大小*/                             |

------------------------------------------------------------------

|                                                                                                 | <----malloc返回的指针指向此处

|                      实际空闲内存区                                                     |

|                                                                                            |

------------------------------------------------------------------

|                       填充区（可选）                                                   |

------------------------------------------------------------------

available 表示此块是否可用（被分配）。为1时表示可以分配，为0时表示被占用。

size表示此块内存的大小。

填充区用来进行块对齐（双字对齐）。

当调用malloc进行内存分配的时候，需要从空闲的内存块中选择一块合适的。选择的方法常用的有三种：首次匹配，下一次匹配，最佳匹配。

首次匹配：从头开始搜索表，选择第一个合适的块。

下一次匹配：和首次匹配类似，但是不是每次都从头搜索，而是从上一次搜索结束的位置开始搜索。

最佳匹配：选择所有合适的空闲块中最小的一块。

下一次匹配的运行速度要比首次匹配快，但空间利用率没有首次匹配高。最佳匹配的空间利用率最高，但运行也是最慢的。

当搜索到合适的空闲块后，这个空闲块往往不会整好合适，基本上都会大一下。多余的部分如果也分配给程序，就造成了内碎片。如果不分配，就要对空闲块进行分割。将多余的部分重新组成一个空闲块。这就有可能造成外碎片。因此，到底怎样处理，要看运行库的实现了。

若两个空闲块整好是连着的，那么把这两个块合并成一个块就可以提高空间的利用率。如果当前块的后一个块是空闲块，那么根据当前块的指针和其长度，很容易得到下一个空闲块的位置指针。但当空闲块在当前块的前面时，就很难获得其指针了。Knuth提出了一种聪明而有效的方法，叫做边界标记。就是复制块头到空闲块的尾部，形成一个块尾。这样，只需将当前块的指针向前移动一个块头大小的距离，就可以得到指向前一个块的块尾的指针，这样，前一个块的所有信息就都得到了。

在实际的实现中，往往引入两个特殊的块------序言块和结尾块。

序言块是程度为零且一直标记为不可分配的块，在整个堆区的最下面（堆区的开始位置）。序言块有块头和块尾。

结尾块在堆区的最上面（堆区的结束位置），也是长度为零且一直为不可分配。结尾块只有块头。

这两个块的引入可以减少很多边界的处理，提高程序的简洁性和效率。

下面是一个简单的实现的例子：

采用首次匹配。

  1 /* 
  2  * File:   my_alloc.h
  3  */
  4 
  5 #ifndef _MY_ALLOC_H
  6 #define    _MY_ALLOC_H
  7 
  8 #ifdef    __cplusplus
  9 extern "C"
 10 {
 11 #endif
 12 
 13 #include <unistd.h>
 14 #define INIT_S 10240 //堆区的默认大小
 15     int is_initialized = 0; //标记是否已经初始化
 16     void *memory_start; //堆区的开始地址
 17     void *memory_end; //系统中断点
 18 
 19     /*
 20      * 内存控制块
 21      * 块头和块尾的结构
 22      */
 23     typedef struct __mem_control_block
 24     {
 25         int available; //是否可用
 26         int size; //大小
 27     } mem_control_block;
 28 
 29     /*
 30       * 初始化堆区。
 31       * 建立堆区的初始结构，设置序言块，结尾块等。
 32       */
 33     void my_malloc_init()
 34     {
 35         /*
 36          * 获得系统中断点，也即堆区的堆顶
 37          */
 38         memory_end = sbrk(0);
 39         /*
 40          * 堆区的开始位置
 41          */
 42         memory_start = memory_end;
 43         /*
 44          * 为堆区预先分配INIT_S个字节。
 45          */
 46         if (sbrk(INIT_S) <= 0)
 47         {
 48             printf("Init Error!\n");
 49             return;
 50         }
 51         memory_end += INIT_S;
 52 
 53         mem_control_block *mcb;
 54         /*序言块*/
 55         /*块头*/
 56         mcb = memory_start;
 57         mcb -> available = 0;
 58         mcb -> size = 0;
 59         /*块尾*/
 60         mcb = (void*)mcb+ sizeof(mem_control_block);
 61         mcb -> available = 0;
 62         mcb -> size = 0;
 63         
 64         /*设置控制块， 块头*/
 65         mcb = memory_start + 2 * sizeof(mem_control_block);
 66         mcb -> available = 1;
 67         /*这个块的长度为整个堆区（除去控制块的长度）*/
 68         mcb -> size = INIT_S - 5 * sizeof (mem_control_block);
 69         /*设置边界标记，块尾*/
 70         mcb = memory_end - 2 * sizeof (mem_control_block);
 71         mcb -> available = 1;
 72         mcb -> size = INIT_S - 5 * sizeof (mem_control_block);
 73 
 74 
 75         /*结尾块*/
 76         mcb = memory_end - sizeof (mem_control_block);
 77         mcb -> available = 0;
 78         mcb -> size = 0;
 79 
 80         /*
 81          * 已经进行了初始化
 82          */
 83         is_initialized = 1;
 84     }
 85 
 86     /*
 87       * 模拟malloc函数
 88       */
 89     void * my_malloc(int size)
 90     {
 91         if (!is_initialized)
 92         {
 93             my_malloc_init();
 94         }
 95 
 96         /*分配的内存块的地址*/
 97         void * mem_location = 0;
 98 
 99         /*内存控制块的指针*/
100         mem_control_block *curr_mcb, *tail;
101 
102         /*从头开始遍历*/
103         curr_mcb = memory_start;
104 
105         while ((void*)curr_mcb < memory_end)
106         {
107             if (curr_mcb -> available)/*找到一个空闲块*/
108             {
109                 if (curr_mcb -> size >= size && curr_mcb -> size < size + 2 * sizeof (mem_control_block))
110                     /*大小合适，多余的空间不够进行分割的。也就是剩余的空间无法满足块头和块尾所需要的空间。*/
111                 {
112                     /*获得返回的内存地址*/
113                     /*
114                           *     此处必须把curr_mcb转成void*的格式！！
115                           *  否则，在加的时候是以sizeof(mem_control_block)的倍数增加，而不是仅仅加一！！
116                           */
117                     mem_location = (void *) curr_mcb + sizeof (mem_control_block);
118                     /*标记已经占用*/
119                     curr_mcb -> available = 0;
120 
121                     /*获得边界标记的指针，块尾*/
122                     tail = (void *) curr_mcb + sizeof (mem_control_block) + curr_mcb -> size;
123 
124                     /*标记已经占用*/
125                     tail -> available = 0;
126                     break;
127                 }
128                 else if (curr_mcb -> size > size + 2 * sizeof (mem_control_block))
129                     /*进行分割*/
130                 {
131                     int old_size = curr_mcb -> size;
132                     /*获得分配的内存块的地址*/
133                     mem_location = (void *) curr_mcb + sizeof (mem_control_block);
134                     /*标记已经占用*/
135                     curr_mcb -> available = 0;
136                     curr_mcb -> size = size;
137                     /*获得边界标记的指针，块尾*/
138                     tail = (void *) curr_mcb + sizeof (mem_control_block) + size;
139                     /*标记已经占用*/
140                     tail -> available = 0;
141                     tail -> size = size;
142 
143                     /*将余下的部分分割成新的空闲块*/
144                     mem_control_block *hd, *tl; /*新块的块头和块尾*/
145                     /*块头*/
146                     hd = (void *) tail + sizeof (mem_control_block);
147                     hd -> available = 1;
148                     hd -> size = old_size - size - 2 * sizeof (mem_control_block);
149                     /*块尾*/
150                     tl = (void *) hd + hd -> size + sizeof (mem_control_block);
151                     tl -> available = 1;
152                     tl -> size = hd -> size;
153 
154                     break;
155                 }
156             }
157 
158             /*指向下一个块*/
159             curr_mcb = (void*) curr_mcb + curr_mcb -> size + 2 * sizeof (mem_control_block);
160         }
161 
162         /*没有找到合适的块，则扩展堆区，分配合适大小的内存加到堆区*/
163         if (!mem_location)
164         {
165             /*申请空间*/
166             if (sbrk(size + 2 * sizeof (mem_control_block)) <= 0)
167             {
168                 printf("Sbrk Error!\n");
169                 return 0;
170             }
171             /*设置控制块的信息*/
172             curr_mcb = (void*)memory_end - sizeof(mem_control_block);
173             curr_mcb -> available = 0;
174             curr_mcb -> size = size;
175             /*设置边界标记，块尾的信息*/
176             tail = (void*) curr_mcb + curr_mcb -> size + sizeof (mem_control_block);
177             tail -> available = 0;
178             tail -> size = size;
179 
180             /*获得分配的内存块的地址*/
181             mem_location = (void*)curr_mcb + sizeof (mem_control_block);
182 
183             memory_end =  memory_end + size + 2 * sizeof (mem_control_block);
184              /*设置结尾块*/
185             tail = (void*)memory_end - sizeof(mem_control_block);
186             tail -> available = 0;
187             tail -> size = 0;
188         }
189 
190         return mem_location;
191     }
192     /*
193      * 模拟free函数
194      */
195     void my_free(void *ptr)
196     {
197         if (ptr <= 0)
198         {
199             return;
200         }
201 
202         mem_control_block *curr;
203         /*指向控制块的地址*/
204         curr = ptr - sizeof (mem_control_block);
205 
206         
207 
208         /*标记为空闲，可用*/
209         curr->available = 1;
210         /*
211          * 合并
212          */
213         mem_control_block *pre, *next, *tmp;
214         
215         /*获得前一个块的块头地址*/
216         pre = ptr - 2 * sizeof (mem_control_block);/*这条语句获得了前一个块的块尾的地址*/
217         pre = (void *) pre - pre -> size - sizeof (mem_control_block);/*进一步计算块头的地址*/
218 
219         /*获得后一个块的块头地址*/
220         next = ptr + curr -> size + sizeof (mem_control_block);
221 
222         if (!pre -> available && next -> available)/*只有后一个块空闲*/
223         {
224             curr -> size += (next -> size + 2 * sizeof (mem_control_block));
225             /*设置块尾*/
226             tmp = (void *) curr + curr -> size + sizeof (mem_control_block);
227             tmp -> available = 1;
228             tmp -> size = curr -> size;
229         }
230         else if (pre -> available && !next -> available)/*只有前一个块空闲*/
231         {
232             pre -> size += (curr -> size + 2 * sizeof (mem_control_block));
233             /*设置块尾*/
234             tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
235             tmp -> available = 1;
236             tmp -> size = pre -> size;
237         }
238         else if (pre -> available && next -> available)/*前后都块空闲*/
239         {
240             pre -> size += (curr -> size + 4 * sizeof (mem_control_block) + next -> size);
241             /*设置块尾*/
242             tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
243             tmp -> available = 1;
244             tmp -> size = pre -> size;
245         }
246 
247         return;
248 
249     }
250 
251     void print_info()
252     {
253         printf("printf_info:\n");
254         mem_control_block *curr = memory_start;
255         while ((void*)curr < memory_end)
256         {
257 
258             printf("a? %d s: %d %d %d\n", curr ->available, curr ->size, memory_end, curr);
259             curr = (void*) curr + curr -> size + 2 * sizeof (mem_control_block);
260         }
261     }
262 
263 
264 #ifdef    __cplusplus
265 }
266 #endif
267 
268 #endif    /* _MY_ALLOC_H */
269 
270 

  1 /* 
  2  * File:   my_alloc.h
  3  */
  4 
  5 #ifndef _MY_ALLOC_H
  6 #define    _MY_ALLOC_H
  7 
  8 #ifdef    __cplusplus
  9 extern "C"
 10 {
 11 #endif
 12 
 13 #include <unistd.h>
 14 #define INIT_S 10240 //堆区的默认大小
 15     int is_initialized = 0; //标记是否已经初始化
 16     void *memory_start; //堆区的开始地址
 17     void *memory_end; //系统中断点
 18 
 19     /*
 20      * 内存控制块
 21      * 块头和块尾的结构
 22      */
 23     typedef struct __mem_control_block
 24     {
 25         int available; //是否可用
 26         int size; //大小
 27     } mem_control_block;
 28 
 29     /*
 30       * 初始化堆区。
 31       * 建立堆区的初始结构，设置序言块，结尾块等。
 32       */
 33     void my_malloc_init()
 34     {
 35         /*
 36          * 获得系统中断点，也即堆区的堆顶
 37          */
 38         memory_end = sbrk(0);
 39         /*
 40          * 堆区的开始位置
 41          */
 42         memory_start = memory_end;
 43         /*
 44          * 为堆区预先分配INIT_S个字节。
 45          */
 46         if (sbrk(INIT_S) <= 0)
 47         {
 48             printf("Init Error!\n");
 49             return;
 50         }
 51         memory_end += INIT_S;
 52 
 53         mem_control_block *mcb;
 54         /*序言块*/
 55         /*块头*/
 56         mcb = memory_start;
 57         mcb -> available = 0;
 58         mcb -> size = 0;
 59         /*块尾*/
 60         mcb = (void*)mcb+ sizeof(mem_control_block);
 61         mcb -> available = 0;
 62         mcb -> size = 0;
 63         
 64         /*设置控制块， 块头*/
 65         mcb = memory_start + 2 * sizeof(mem_control_block);
 66         mcb -> available = 1;
 67         /*这个块的长度为整个堆区（除去控制块的长度）*/
 68         mcb -> size = INIT_S - 5 * sizeof (mem_control_block);
 69         /*设置边界标记，块尾*/
 70         mcb = memory_end - 2 * sizeof (mem_control_block);
 71         mcb -> available = 1;
 72         mcb -> size = INIT_S - 5 * sizeof (mem_control_block);
 73 
 74 
 75         /*结尾块*/
 76         mcb = memory_end - sizeof (mem_control_block);
 77         mcb -> available = 0;
 78         mcb -> size = 0;
 79 
 80         /*
 81          * 已经进行了初始化
 82          */
 83         is_initialized = 1;
 84     }
 85 
 86     /*
 87       * 模拟malloc函数
 88       */
 89     void * my_malloc(int size)
 90     {
 91         if (!is_initialized)
 92         {
 93             my_malloc_init();
 94         }
 95 
 96         /*分配的内存块的地址*/
 97         void * mem_location = 0;
 98 
 99         /*内存控制块的指针*/
100         mem_control_block *curr_mcb, *tail;
101 
102         /*从头开始遍历*/
103         curr_mcb = memory_start;
104 
105         while ((void*)curr_mcb < memory_end)
106         {
107             if (curr_mcb -> available)/*找到一个空闲块*/
108             {
109                 if (curr_mcb -> size >= size && curr_mcb -> size < size + 2 * sizeof (mem_control_block))
110                     /*大小合适，多余的空间不够进行分割的。也就是剩余的空间无法满足块头和块尾所需要的空间。*/
111                 {
112                     /*获得返回的内存地址*/
113                     /*
114                           *     此处必须把curr_mcb转成void*的格式！！
115                           *  否则，在加的时候是以sizeof(mem_control_block)的倍数增加，而不是仅仅加一！！
116                           */
117                     mem_location = (void *) curr_mcb + sizeof (mem_control_block);
118                     /*标记已经占用*/
119                     curr_mcb -> available = 0;
120 
121                     /*获得边界标记的指针，块尾*/
122                     tail = (void *) curr_mcb + sizeof (mem_control_block) + curr_mcb -> size;
123 
124                     /*标记已经占用*/
125                     tail -> available = 0;
126                     break;
127                 }
128                 else if (curr_mcb -> size > size + 2 * sizeof (mem_control_block))
129                     /*进行分割*/
130                 {
131                     int old_size = curr_mcb -> size;
132                     /*获得分配的内存块的地址*/
133                     mem_location = (void *) curr_mcb + sizeof (mem_control_block);
134                     /*标记已经占用*/
135                     curr_mcb -> available = 0;
136                     curr_mcb -> size = size;
137                     /*获得边界标记的指针，块尾*/
138                     tail = (void *) curr_mcb + sizeof (mem_control_block) + size;
139                     /*标记已经占用*/
140                     tail -> available = 0;
141                     tail -> size = size;
142 
143                     /*将余下的部分分割成新的空闲块*/
144                     mem_control_block *hd, *tl; /*新块的块头和块尾*/
145                     /*块头*/
146                     hd = (void *) tail + sizeof (mem_control_block);
147                     hd -> available = 1;
148                     hd -> size = old_size - size - 2 * sizeof (mem_control_block);
149                     /*块尾*/
150                     tl = (void *) hd + hd -> size + sizeof (mem_control_block);
151                     tl -> available = 1;
152                     tl -> size = hd -> size;
153 
154                     break;
155                 }
156             }
157 
158             /*指向下一个块*/
159             curr_mcb = (void*) curr_mcb + curr_mcb -> size + 2 * sizeof (mem_control_block);
160         }
161 
162         /*没有找到合适的块，则扩展堆区，分配合适大小的内存加到堆区*/
163         if (!mem_location)
164         {
165             /*申请空间*/
166             if (sbrk(size + 2 * sizeof (mem_control_block)) <= 0)
167             {
168                 printf("Sbrk Error!\n");
169                 return 0;
170             }
171             /*设置控制块的信息*/
172             curr_mcb = (void*)memory_end - sizeof(mem_control_block);
173             curr_mcb -> available = 0;
174             curr_mcb -> size = size;
175             /*设置边界标记，块尾的信息*/
176             tail = (void*) curr_mcb + curr_mcb -> size + sizeof (mem_control_block);
177             tail -> available = 0;
178             tail -> size = size;
179 
180             /*获得分配的内存块的地址*/
181             mem_location = (void*)curr_mcb + sizeof (mem_control_block);
182 
183             memory_end =  memory_end + size + 2 * sizeof (mem_control_block);
184              /*设置结尾块*/
185             tail = (void*)memory_end - sizeof(mem_control_block);
186             tail -> available = 0;
187             tail -> size = 0;
188         }
189 
190         return mem_location;
191     }
192     /*
193      * 模拟free函数
194      */
195     void my_free(void *ptr)
196     {
197         if (ptr <= 0)
198         {
199             return;
200         }
201 
202         mem_control_block *curr;
203         /*指向控制块的地址*/
204         curr = ptr - sizeof (mem_control_block);
205 
206         
207 
208         /*标记为空闲，可用*/
209         curr->available = 1;
210         /*
211          * 合并
212          */
213         mem_control_block *pre, *next, *tmp;
214         
215         /*获得前一个块的块头地址*/
216         pre = ptr - 2 * sizeof (mem_control_block);/*这条语句获得了前一个块的块尾的地址*/
217         pre = (void *) pre - pre -> size - sizeof (mem_control_block);/*进一步计算块头的地址*/
218 
219         /*获得后一个块的块头地址*/
220         next = ptr + curr -> size + sizeof (mem_control_block);
221 
222         if (!pre -> available && next -> available)/*只有后一个块空闲*/
223         {
224             curr -> size += (next -> size + 2 * sizeof (mem_control_block));
225             /*设置块尾*/
226             tmp = (void *) curr + curr -> size + sizeof (mem_control_block);
227             tmp -> available = 1;
228             tmp -> size = curr -> size;
229         }
230         else if (pre -> available && !next -> available)/*只有前一个块空闲*/
231         {
232             pre -> size += (curr -> size + 2 * sizeof (mem_control_block));
233             /*设置块尾*/
234             tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
235             tmp -> available = 1;
236             tmp -> size = pre -> size;
237         }
238         else if (pre -> available && next -> available)/*前后都块空闲*/
239         {
240             pre -> size += (curr -> size + 4 * sizeof (mem_control_block) + next -> size);
241             /*设置块尾*/
242             tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
243             tmp -> available = 1;
244             tmp -> size = pre -> size;
245         }
246 
247         return;
248 
249     }
250 
251     void print_info()
252     {
253         printf("printf_info:\n");
254         mem_control_block *curr = memory_start;
255         while ((void*)curr < memory_end)
256         {
257 
258             printf("a? %d s: %d %d %d\n", curr ->available, curr ->size, memory_end, curr);
259             curr = (void*) curr + curr -> size + 2 * sizeof (mem_control_block);
260         }
261     }
262 
263 
264 #ifdef    __cplusplus
265 }
266 #endif
267 
268 #endif    /* _MY_ALLOC_H */
269 
270