malloc实现原理简介

以你之姓@ 2022-08-26 11:16 134阅读 0赞

malloc（）是C语言中动态[存储管理][Link 1] 的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，[返回值][Link 2] 是一个指向所分配的连续存储域的起始地址的指针。   
　　动态[内存分配][Link 3] 就 是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据 程序的需要即时分配，且分配的大小就是程序要求的大小。本文简单介绍动态内存分配函数malloc（）及几种实现方法。   
　　1． 简介   
　　malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如[内存不足][Link 4] ）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。   
　　2． 函数说明   
　 　C语言的动态存储管理由一组标准库函数实现，其原型在标准文件<stdlib.h>里描述，需要用这些功能时应包含这个文件。与动态存储分 配有关的函数共有四个，其中就包括存储分配函数malloc（）。函数原型是：void \*malloc (size\_t n);这里的size\_t是标准库里定义的一个类型，它是一个无符号整型。这个整型能够满足所有对存储块大小描述的需要，具体相当于哪个整型由具体的C系 统确定。malloc的返回值为(void \*)类型（这是通用指针的一个重要用途），它分配一片能存放大小为n的数据的存储块，返回对应的指针值；如果不能满足申请（找不到能满足要求的存储块）就 返回NULL。在使用时，应该把malloc的返回值转换到特定指针类型，赋给一个指针。   
　　注意，虽然这里的存储块是通过动态分配得到的，但 是它的大小也是确定的，同样不允许越界使用。例如上面程序段分配的块里能存n个双精度数据，随后的使用就必须在这个范围内进行。越界使用动态分配的存储 块，尤其是越界赋值，可能引起非常严重的后果，通常会破坏程序的运行系统，可能造成本程序或者整个[计算机系统][Link 5] 垮台。   
　　下例是一个动态分配的例子：   
　　\#include <stdlib.h>   
　　main()   
　　\{   
　　int count,\*array; /\*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址\*/   
　　if((array(int \*) malloc (10\*[sizeof][] (int)))==NULL)   
　　\{   
　　printf("不能成功分配存储空间。");   
　　exit(1);   
　　\}   
　　for (count=0;count〈10;count++) /\*给数组赋值\*/   
　　array\[count\]=count;   
　　for(count=0;count〈10;count++) /\*打印数组元素\*/   
　　printf("%2d",array\[count\]);   
　　\}   
　　上例中动态分配了10个整型存储区域，然后进行赋值并打印。例中if((array(int \*) malloc (10\*sizeof(int)))==NULL)语句可以分为以下几步：   
　　1）分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针   
　　2）把此整型指针地址赋给array   
　　3）检测返回值是否为NULL   
　　3． malloc（）工作机制   
　 　malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足 用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传 给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片 段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检 查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。   
　　4． malloc（）在操作系统中的实现   
　　在 C 程序中，多次使用malloc () 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。   
　　在大部分操作系统中，内存分配由以下两个简单的函数来处理：   
　　void \*malloc (long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。   
　　void free(void \*firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。   
　　malloc\_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效[内存地址][Link 6] ，然后建立起指向我们管理的内存的指针。这三个变量都是[全局变量][Link 7] ：   
　　清单 1. 我们的简单分配程序的全局变量   
　　int has\_initialized = 0;   
　　void \*managed\_memory\_start;   
　　void \*last\_valid\_address;   
　　如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者 当前中断点。在很多 [UNIX][] ? 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量：   
　　清单 2. 分配程序初始化函数   
　　/\* Include the sbrk function \*/   
　　\#include   
　　void malloc\_init()   
　　\{   
　　/\* [grab][] the last valid address from the OS \*/   
　　last\_valid\_address = sbrk(0);   
　　/\* we don't have any memory to manage yet, so   
　　\*just set the beginning [to be][] last\_valid\_address   
　　\*/   
　　managed\_memory\_start = last\_valid\_address;   
　　/\* Okay, we're initialized and ready to go \*/   
　　has\_initialized = 1;   
　　\}   
　 　现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构：   
　　清单 3. 内存控制块结构定义   
　　struct mem\_control\_block \{   
　　int is\_available;   
　　int size;   
　　\};   
　 　现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的 内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。   
　　在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem\_control\_block) 个字节，并将其标记为可用的。这里是对应的代码：   
　　清单 4. 解除分配函数   
　　void free(void \*firstbyte) \{   
　　struct mem\_control\_block \*mcb;   
　　/\* Backup from the given pointer to find the   
　　\* mem\_control\_block   
　　\*/   
　　mcb = firstbyte - sizeof(struct mem\_control\_block);   
　　/\* Mark the block as being available \*/   
　　mcb->is\_available = 1;   
　　/\* That's It! We're done. \*/   
　　return;   
　　\}   
　　如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述：   
　　清单 5. 主分配程序的伪代码   
　　1. If our allocator has not been initialized, initialize it.   
　　2. Add sizeof(struct mem\_control\_block) to the size requested.   
　　3. start at managed\_memory\_start.   
　　4. Are we at last\_valid address?   
　　5. If [we are][] :   
　　A. We didn't find any existing space that was large enough   
　　-- ask the operating system for more and return that.   
　　6. Otherwise:   
　　A. Is the current space available (check is\_available from   
　　the mem\_control\_block)?   
　　B. If it is:   
　　i) Is it large enough (check "size" from the   
　　mem\_control\_block)?   
　　ii) If so:   
　　a. Mark it as unavailable   
　　b. Move past mem\_control\_block and return the   
　　pointer   
　　iii) Otherwise:   
　　a. Move forward "size" bytes   
　　b. Go back go step 4   
　　C. Otherwise:   
　　i) Move forward "size" bytes   
　　ii) Go back to step 4   
　　我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码：   
　　清单 6. 主分配程序   
　　void \*malloc(long numbytes) \{   
　　/\* Holds where we are looking in memory \*/   
　　void \*current\_location;   
　　/\* This is the same as current\_location, but cast to a   
　　\* memory\_control\_block   
　　\*/   
　　struct mem\_control\_block \*current\_location\_mcb;   
　　/\* This is the memory location [we will][] return. It will   
　　\* be set to 0 until we find something suitable   
　　\*/   
　　void \*memory\_location;   
　　/\* Initialize if we haven't already done so \*/   
　　if(! has\_initialized) \{   
　　malloc\_init();   
　　\}   
　　/\* The memory we search for has to include the memory   
　　\* control block, but the users of malloc don't need   
　　\* to know this, so we'll just add it in for them.   
　　\*/   
　　numbytes = numbytes + sizeof(struct mem\_control\_block);   
　　/\* [Set][] memory\_location to 0 until we find a suitable   
　　\* location   
　　\*/   
　　memory\_location = 0;   
　　/\* [Begin][] searching at the start of managed memory \*/   
　　current\_location = managed\_memory\_start;   
　　/\* Keep going until we have searched all allocated space \*/   
　　while(current\_location != last\_valid\_address)   
　　\{   
　　/\* current\_location and current\_location\_mcb point   
　　\* to the same address. However, current\_location\_mcb   
　　\* is of the correct type, so we can use it as a struct.   
　　\* current\_location is a void pointer so we can use it   
　　\* to calculate addresses.   
　　\*/   
　　current\_location\_mcb =   
　　(struct mem\_control\_block \*)current\_location;   
　　if(current\_location\_mcb->is\_available)   
　　\{   
　　if(current\_location\_mcb->size >= numbytes)   
　　\{   
　　/\* Woohoo! We've found an open,   
　　\* appropriately-size location.   
　　\*/   
　　/\* It is no longer available \*/   
　　current\_location\_mcb->is\_available = 0;   
　　/\* We own it \*/   
　　memory\_location = current\_location;   
　　/\* [Leave][] the loop \*/   
　　break;   
　　\}   
　　\}   
　　/\* If [we made it][] here, it's because the Current memory   
　　\* block not suitable; move to [the next][] one   
　　\*/   
　　current\_location = current\_location +   
　　current\_location\_mcb->size;   
　　\}   
　　/\* If we still don't have a valid location, we'll   
　　\* have to ask the operating system for more memory   
　　\*/   
　　if(! memory\_location)   
　　\{   
　　/\* Move the program break numbytes further \*/   
　　sbrk(numbytes);   
　　/\* The new memory will be where the last valid   
　　\* address left off   
　　\*/   
　　memory\_location = last\_valid\_address;   
　　/\* We'll move the last valid address forward   
　　\* numbytes   
　　\*/   
　　last\_valid\_address = last\_valid\_address + numbytes;   
　　/\* We need to initialize the mem\_control\_block \*/   
　　current\_location\_mcb = memory\_location;   
　　current\_location\_mcb->is\_available = 0;   
　　current\_location\_mcb->size = numbytes;   
　　\}   
　　/\* Now, no matter what (well, except for error conditions),   
　　\* memory\_location has the address of the memory, including   
　　\* the mem\_control\_block   
　　\*/   
　　/\* Move the pointer past the mem\_control\_block \*/   
　　memory\_location = memory\_location + sizeof(struct mem\_control\_block);   
　　/\* Return the pointer \*/   
　　return memory\_location;   
　　\}   
　　这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可。   
　　5． malloc（）的其他实现   
　　malloc() 的实现有很多，这些实现各有优点与缺点。在设计一个分配程序时，要面临许多需要[折衷][Link 8] 的选择，其中包括：   
　　分配的速度。   
　　回收的速度。   
　　有线程的环境的行为。   
　　内存将要被用光时的行为。   
　　局部缓存。   
　　簿记（Bookkeeping）内存开销。   
　　虚拟内存环境中的行为。   
　　小的或者大的对象。   
　　实时保证。   
　　每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虚拟内存系统方面较差，所以它最适于处理大的对象。   
　　还有其他许多分配程序可以使用。其中包括：   
　　Doug Lea Malloc：Doug Lea Malloc 实际上是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，[GNU][] libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构，但是它加入了索引，这使得搜索速度更快，并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存， 以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的 [参考资料][Link 9] 部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。   
　　[BSD][] Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 [FreeBSD][] 之中，这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。所以，如果您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，但是可能会浪费内存。在 参考资料部分中，有一篇描述该实现的文章。   
　　Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此，它的构造以锁的使用为中心，从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在 参考资料部分中，有一篇描述该实现的文章。   
　　众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，如果不熟悉分配程序的设计，那么定制分配程序通常会带来比它们解决的问题更多的问题。

附：：

C++中内存的动态分配与管理永远是一个让C++开发者头痛的问题，本文通过对C++中内存的动态分配释放的基本原理的介绍，让读者朋友能对C++中的内存的动态分配与释放有较为深入的理解，从而更好驾驭C++程序。

空闲链表如何从中选择分配内存块？这是对问题（2）的解答。有下面四种选择方法。  
  
  
    (1)首次适应法（First Fit）：链表按块地址排序。选择第一个满足要求的空闲块。特点：低地址碎片多，高地址碎片少。  
    (2)最佳适应法（Best Fit）：链表按空闲块大小排序。选择满足要求的，且大小最小的空闲块。特点：费时间，并且会出现很小的碎片。  
    (3)最坏适应法（Worst Fit）：链表按空闲块大小排序。选择最大的空闲块。特点：碎片少，容易缺乏大块。  
    (4)循环首次适应法（Next Fit）：链表按块地址排序。从上次分配位置开始找到第一个满足要求的空闲块。特点：碎片分布的又多又均匀。  
  
  
  
  
  
  
  
  
    如何处理被选空闲块中的剩余部分？这是对问题（3）的解答。一般来讲，是要把剩余的部分再插入回到空闲链表中去的。要注意一个空闲块分割成两个块时，需要腾出若干字节作为块的头部尾部等部分。  
  
  
  
  
  
  
  
  
    如何合并被释放的块？这是对问题（4）的解答。有两种方法：立即合并、推迟合并。对于隐式空闲链表，合并的具体过程是，  
  
  
    (1)前后块都已分配：直接释放当前块即可；  
  
  
    (2)前块分配、后块空闲：和后块合并；  
  
  
    (3)前块空闲、后块分配：和前块合并；  
  
  
    (4)前后块都已空闲：和前后块合并；

[Link 1]: http://baike.soso.com/v276803.htm?ch=ch.bk.innerlink
[Link 2]: http://baike.soso.com/v581547.htm?ch=ch.bk.innerlink
[Link 3]: http://baike.soso.com/v53167.htm?ch=ch.bk.innerlink
[Link 4]: http://baike.soso.com/v7705650.htm?ch=ch.bk.innerlink
[Link 5]: http://baike.soso.com/v1695130.htm?ch=ch.bk.innerlink
[sizeof]: http://baike.soso.com/v776815.htm?ch=ch.bk.innerlink
[Link 6]: http://baike.soso.com/v731516.htm?ch=ch.bk.innerlink
[Link 7]: http://baike.soso.com/v112004.htm?ch=ch.bk.innerlink
[UNIX]: http://baike.soso.com/v103172.htm?ch=ch.bk.innerlink
[grab]: http://baike.soso.com/v227505.htm?ch=ch.bk.innerlink
[to be]: http://baike.soso.com/v7709688.htm?ch=ch.bk.innerlink
[we are]: http://baike.soso.com/v7716134.htm?ch=ch.bk.innerlink
[we will]: http://baike.soso.com/v7734094.htm?ch=ch.bk.innerlink
[Set]: http://baike.soso.com/v535663.htm?ch=ch.bk.innerlink
[Begin]: http://baike.soso.com/v5337720.htm?ch=ch.bk.innerlink
[Leave]: http://baike.soso.com/v5151614.htm?ch=ch.bk.innerlink
[we made it]: http://baike.soso.com/v5284572.htm?ch=ch.bk.innerlink
[the next]: http://baike.soso.com/v7659670.htm?ch=ch.bk.innerlink
[Link 8]: http://baike.soso.com/v7724706.htm?ch=ch.bk.innerlink
[GNU]: http://baike.soso.com/v48089.htm?ch=ch.bk.innerlink
[Link 9]: http://baike.soso.com/v98104.htm?ch=ch.bk.innerlink
[BSD]: http://baike.soso.com/v2339816.htm?ch=ch.bk.innerlink
[FreeBSD]: http://baike.soso.com/v229255.htm?ch=ch.bk.innerlink