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

（本文基于linux系统。）

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


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

malloc和free函数的原型如下：

void * malloc(size_t size)

void free(void* ptr)

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

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

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

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

内碎片是指分配给程序的存储空间没有用完，有一部分是闲着的，这部分空间成为内碎片。
外碎片是虽然还有空间可以分配，但是这些空间都是不连续的小块，不能满足程序对连续存储的要求，因此无法分配给程序使用。这些不能满足程序要求的小的可以分配的存储空间成为外碎片。
关于效率的问题，后面会详细说明。

如果空间无限大，那么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 /*内存控制块的指针*/
mem_control_block *curr_mcb, *tail;

/*从头开始遍历*/
curr_mcb = memory_start;

while ((void*)curr_mcb < memory_end)
{
if (curr_mcb -> available)/*找到一个空闲块*/
{
if (curr_mcb -> size >= size && curr_mcb -> size < size + 2 * sizeof (mem_control_block))
/*大小合适，多余的空间不够进行分割的。也就是剩余的空间无法满足块头和块尾所需要的空间。*/
{
/*获得返回的内存地址*/
/*
* 此处必须把curr_mcb转成void*的格式！！
* 否则，在加的时候是以sizeof(mem_control_block)的倍数增加，而不是仅仅加一！！
*/
mem_location = (void *) curr_mcb + sizeof (mem_control_block);
/*标记已经占用*/
curr_mcb -> available = 0;

/*获得边界标记的指针，块尾*/
tail = (void *) curr_mcb + sizeof (mem_control_block) + curr_mcb -> size;

/*标记已经占用*/
tail -> available = 0;
break;
}
else if (curr_mcb -> size > size + 2 * sizeof (mem_control_block))
/*进行分割*/
{
int old_size = curr_mcb -> size;
/*获得分配的内存块的地址*/
mem_location = (void *) curr_mcb + sizeof (mem_control_block);
/*标记已经占用*/
curr_mcb -> available = 0;
curr_mcb -> size = size;
/*获得边界标记的指针，块尾*/
tail = (void *) curr_mcb + sizeof (mem_control_block) + size;
/*标记已经占用*/
tail -> available = 0;
tail -> size = size;

/*将余下的部分分割成新的空闲块*/
mem_control_block *hd, *tl; /*新块的块头和块尾*/
/*块头*/
hd = (void *) tail + sizeof (mem_control_block);
hd -> available = 1;
hd -> size = old_size - size - 2 * sizeof (mem_control_block);
/*块尾*/
tl = (void *) hd + hd -> size + sizeof (mem_control_block);
tl -> available = 1;
tl -> size = hd -> size;

break;
}
}

/*指向下一个块*/
curr_mcb = (void*) curr_mcb + curr_mcb -> size + 2 * sizeof (mem_control_block);
}

/*没有找到合适的块，则扩展堆区，分配合适大小的内存加到堆区*/
if (!mem_location)
{
/*申请空间*/
if (sbrk(size + 2 * sizeof (mem_control_block)) <= 0)
{
printf("Sbrk Error!\n");
return 0;
}
/*设置控制块的信息*/
curr_mcb = (void*)memory_end - sizeof(mem_control_block);
curr_mcb -> available = 0;
curr_mcb -> size = size;
/*设置边界标记，块尾的信息*/
tail = (void*) curr_mcb + curr_mcb -> size + sizeof (mem_control_block);
tail -> available = 0;
tail -> size = size;

/*获得分配的内存块的地址*/
mem_location = (void*)curr_mcb + sizeof (mem_control_block);

memory_end = memory_end + size + 2 * sizeof (mem_control_block);
/*设置结尾块*/
tail = (void*)memory_end - sizeof(mem_control_block);
tail -> available = 0;
tail -> size = 0;
}

return mem_location;
}
/*
* 模拟free函数
*/
void my_free(void *ptr)
{
if (ptr <= 0)
{
return;
}

mem_control_block *curr;
/*指向控制块的地址*/
curr = ptr - sizeof (mem_control_block);

/*标记为空闲，可用*/
curr->available = 1;
/*
* 合并
*/
mem_control_block *pre, *next, *tmp;

/*获得前一个块的块头地址*/
pre = ptr - 2 * sizeof (mem_control_block);/*这条语句获得了前一个块的块尾的地址*/
pre = (void *) pre - pre -> size - sizeof (mem_control_block);/*进一步计算块头的地址*/

/*获得后一个块的块头地址*/
next = ptr + curr -> size + sizeof (mem_control_block);

if (!pre -> available && next -> available)/*只有后一个块空闲*/
{
curr -> size += (next -> size + 2 * sizeof (mem_control_block));
/*设置块尾*/
tmp = (void *) curr + curr -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = curr -> size;
}
else if (pre -> available && !next -> available)/*只有前一个块空闲*/
{
pre -> size += (curr -> size + 2 * sizeof (mem_control_block));
/*设置块尾*/
tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = pre -> size;
}
else if (pre -> available && next -> available)/*前后都块空闲*/
{
pre -> size += (curr -> size + 4 * sizeof (mem_control_block) + next -> size);
/*设置块尾*/
tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = pre -> size;
}

return;

}

void print_info()
{
printf("printf_info:\n");
mem_control_block *curr = memory_start;
while ((void*)curr < memory_end)
{

printf("a? %d s: %d %d %d\n", curr ->available, curr ->size, memory_end, curr);
curr = (void*) curr + curr -> size + 2 * sizeof (mem_control_block);
}
}

#ifdef __cplusplus
}
#endif

#endif /* _MY_ALLOC_H */

在真正的实现中，不可能使用上面程序中的结构体来表示控制块（块头，块尾）。这样虽然简单但很浪费空间。实际中一般都是位来表示，这样节省空间，但是对编程要求细致入微，来不得半点马虎。上面的例子仅仅是模拟一下。有兴趣的读者可以看看gun libc的代码。

隐式空闲链表的实现简单，但效率较低。因为运行的时候需要很多顺寻查找。实际的运用中可以使用分离的空闲链表或显示空闲链表等方法。有兴趣的读者可以参考《深入理解计算机系统》Randal E.Bryant David O'Hallaron 中国电力出版社的汉译版 第十章 10.9节动态存储分配。

好了，就写这么多。如有错误还请各位读者指正。

参考资料：《深入理解计算机系统》Randal E.Bryant David O'Hallaron 著 中国电力出版社

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 /*内存控制块的指针*/
mem_control_block *curr_mcb, *tail;

/*从头开始遍历*/
curr_mcb = memory_start;

while ((void*)curr_mcb < memory_end)
{
if (curr_mcb -> available)/*找到一个空闲块*/
{
if (curr_mcb -> size >= size && curr_mcb -> size < size + 2 * sizeof (mem_control_block))
/*大小合适，多余的空间不够进行分割的。也就是剩余的空间无法满足块头和块尾所需要的空间。*/
{
/*获得返回的内存地址*/
/*
* 此处必须把curr_mcb转成void*的格式！！
* 否则，在加的时候是以sizeof(mem_control_block)的倍数增加，而不是仅仅加一！！
*/
mem_location = (void *) curr_mcb + sizeof (mem_control_block);
/*标记已经占用*/
curr_mcb -> available = 0;

/*获得边界标记的指针，块尾*/
tail = (void *) curr_mcb + sizeof (mem_control_block) + curr_mcb -> size;

/*标记已经占用*/
tail -> available = 0;
break;
}
else if (curr_mcb -> size > size + 2 * sizeof (mem_control_block))
/*进行分割*/
{
int old_size = curr_mcb -> size;
/*获得分配的内存块的地址*/
mem_location = (void *) curr_mcb + sizeof (mem_control_block);
/*标记已经占用*/
curr_mcb -> available = 0;
curr_mcb -> size = size;
/*获得边界标记的指针，块尾*/
tail = (void *) curr_mcb + sizeof (mem_control_block) + size;
/*标记已经占用*/
tail -> available = 0;
tail -> size = size;

/*将余下的部分分割成新的空闲块*/
mem_control_block *hd, *tl; /*新块的块头和块尾*/
/*块头*/
hd = (void *) tail + sizeof (mem_control_block);
hd -> available = 1;
hd -> size = old_size - size - 2 * sizeof (mem_control_block);
/*块尾*/
tl = (void *) hd + hd -> size + sizeof (mem_control_block);
tl -> available = 1;
tl -> size = hd -> size;

break;
}
}

/*指向下一个块*/
curr_mcb = (void*) curr_mcb + curr_mcb -> size + 2 * sizeof (mem_control_block);
}

/*没有找到合适的块，则扩展堆区，分配合适大小的内存加到堆区*/
if (!mem_location)
{
/*申请空间*/
if (sbrk(size + 2 * sizeof (mem_control_block)) <= 0)
{
printf("Sbrk Error!\n");
return 0;
}
/*设置控制块的信息*/
curr_mcb = (void*)memory_end - sizeof(mem_control_block);
curr_mcb -> available = 0;
curr_mcb -> size = size;
/*设置边界标记，块尾的信息*/
tail = (void*) curr_mcb + curr_mcb -> size + sizeof (mem_control_block);
tail -> available = 0;
tail -> size = size;

/*获得分配的内存块的地址*/
mem_location = (void*)curr_mcb + sizeof (mem_control_block);

memory_end = memory_end + size + 2 * sizeof (mem_control_block);
/*设置结尾块*/
tail = (void*)memory_end - sizeof(mem_control_block);
tail -> available = 0;
tail -> size = 0;
}

return mem_location;
}
/*
* 模拟free函数
*/
void my_free(void *ptr)
{
if (ptr <= 0)
{
return;
}

mem_control_block *curr;
/*指向控制块的地址*/
curr = ptr - sizeof (mem_control_block);

/*标记为空闲，可用*/
curr->available = 1;
/*
* 合并
*/
mem_control_block *pre, *next, *tmp;

/*获得前一个块的块头地址*/
pre = ptr - 2 * sizeof (mem_control_block);/*这条语句获得了前一个块的块尾的地址*/
pre = (void *) pre - pre -> size - sizeof (mem_control_block);/*进一步计算块头的地址*/

/*获得后一个块的块头地址*/
next = ptr + curr -> size + sizeof (mem_control_block);

if (!pre -> available && next -> available)/*只有后一个块空闲*/
{
curr -> size += (next -> size + 2 * sizeof (mem_control_block));
/*设置块尾*/
tmp = (void *) curr + curr -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = curr -> size;
}
else if (pre -> available && !next -> available)/*只有前一个块空闲*/
{
pre -> size += (curr -> size + 2 * sizeof (mem_control_block));
/*设置块尾*/
tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = pre -> size;
}
else if (pre -> available && next -> available)/*前后都块空闲*/
{
pre -> size += (curr -> size + 4 * sizeof (mem_control_block) + next -> size);
/*设置块尾*/
tmp = (void *) pre + pre -> size + sizeof (mem_control_block);
tmp -> available = 1;
tmp -> size = pre -> size;
}

return;

}

void print_info()
{
printf("printf_info:\n");
mem_control_block *curr = memory_start;
while ((void*)curr < memory_end)
{

printf("a? %d s: %d %d %d\n", curr ->available, curr ->size, memory_end, curr);
curr = (void*) curr + curr -> size + 2 * sizeof (mem_control_block);
}
}

#ifdef __cplusplus
}
#endif

#endif /* _MY_ALLOC_H */