内存管理内幕mallco及free函数实现

时间  2019-11-09
标签 内存 管理 内幕 mallco free 函数 实现 繁體版
原文   原文链接

原文：https://www.ibm.com/developerworks/cn/linux/l-memory/html

为何必须管理内存java

内存管理是计算机编程最为基本的领域之一。在不少脚本语言中，您没必要担忧内存是如何管理的，这并不能使得内存管理的重要性有一点点下降。对实际编程来讲，理解您的内存管理器的能力与局限性相当重要。在大部分系统语言中，好比 C 和 C++，您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。node

追溯到在 Apple II 上进行汇编语言编程的时代，那时内存管理还不是个大问题。您实际上在运行整个系统。系统有多少内存，您就有多少内存。您甚至没必要费心思去弄明白它有多少内存，由于每一台机器的内存数量都相同。因此，若是内存须要很是固定，那么您只须要选择一个内存范围并使用它便可。linux

不过，即便是在这样一个简单的计算机中，您也会有问题，尤为是当您不知道程序的每一个部分将须要多少内存时。若是您的空间有限，而内存需求是变化的，那么您须要一些方法来知足这些需求：程序员

  • 肯定您是否有足够的内存来处理数据。
  • 从可用的内存中获取一部份内存。
  • 向可用内存池（pool）中返回部份内存，以使其能够由程序的其余部分或者其余程序使用。

实现这些需求的程序库称为 分配程序（allocators），由于它们负责分配和回收内存。程序的动态性越强，内存管理就越重要，您的内存分配程序的选择也就更重要。让咱们来了解可用于内存管理的不一样方法，它们的好处与不足，以及它们最适用的情形。web

回页首算法

C 风格的内存分配程序shell

C 编程语言提供了两个函数来知足咱们的三个需求：apache

  • malloc：该函数分配给定的字节数，并返回一个指向它们的指针。若是没有足够的可用内存，那么它返回一个空指针。
  • free：该函数得到指向由 malloc 分配的内存片断的指针，并将其释放，以便之后的程序或操做系统使用（实际上，一些 malloc 实现只能将内存归还给程序，而没法将内存归还给操做系统）。

物理内存和虚拟内存编程

要理解内存在程序中是如何分配的，首先须要理解如何将内存从操做系统分配给程序。计算机上的每个进程都认为本身能够访问全部的物理内存。显然，因为同时在运行多个程序，因此每一个进程不可能拥有所有内存。实际上，这些进程使用的是 虚拟内存。

只是做为一个例子，让咱们假定您的程序正在访问地址为 629 的内存。不过，虚拟内存系统不须要将其存储在位置为 629 的 RAM 中。实际上，它甚至能够不在 RAM 中 —— 若是物理 RAM 已经满了，它甚至可能已经被转移到硬盘上！因为这类地址没必要反映内存所在的物理位置，因此它们被称为虚拟内存。操做系统维持着一个虚拟地址到物理地址的转换的表，以便计算机硬件能够正确地响应地址请求。而且，若是地址在硬盘上而不是在 RAM 中，那么操做系统将暂时中止您的进程，将其余内存转存到硬盘中，从硬盘上加载被请求的内存，而后再从新启动您的进程。这样，每一个进程都得到了本身可使用的地址空间，能够访问比您物理上安装的内存更多的内存。

在 32-位 x86 系统上，每个进程能够访问 4 GB 内存。如今，大部分人的系统上并无 4 GB 内存，即便您将 swap 也算上， 每一个进程所使用的内存也确定少于 4 GB。所以，当加载一个进程时，它会获得一个取决于某个称为 系统中断点（system break）的特定地址的初始内存分配。该地址以后是未被映射的内存 —— 用于在 RAM 或者硬盘中没有分配相应物理位置的内存。所以，若是一个进程运行超出了它初始分配的内存，那么它必须请求操做系统“映射进来（map in）”更多的内存。（映射是一个表示一一对应关系的数学术语 —— 当内存的虚拟地址有一个对应的物理地址来存储内存内容时，该内存将被映射。）

基于 UNIX 的系统有两个可映射到附加内存中的基本系统调用：

  • brk： brk() 是一个很是简单的系统调用。还记得系统中断点吗？该位置是进程映射的内存边界。 brk() 只是简单地将这个位置向前或者向后移动，就能够向进程添加内存或者从进程取走内存。
  • mmap： mmap()，或者说是“内存映像”，相似于 brk()，可是更为灵活。首先，它能够映射任何位置的内存，而不仅仅只局限于进程。其次，它不只能够将虚拟地址映射到物理的 RAM 或者 swap，它还能够将它们映射到文件和文件位置，这样，读写内存将对文件中的数据进行读写。不过，在这里，咱们只关心 mmap 向进程添加被映射的内存的能力。 munmap() 所作的事情与 mmap() 相反。

如您所见， brk() 或者 mmap() 均可以用来向咱们的进程添加额外的虚拟内存。在咱们的例子中将使用 brk()，由于它更简单，更通用。

实现一个简单的分配程序

若是您曾经编写过不少 C 程序，那么您可能曾屡次使用过 malloc() 和 free()。不过，您可能没有用一些时间去思考它们在您的操做系统中是如何实现的。本节将向您展现 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。

要试着运行这些示例，须要先 复制本代码清单，并将其粘贴到一个名为 malloc.c 的文件中。接下来，我将一次一个部分地对该清单进行解释。

在大部分操做系统中，内存分配由如下两个简单的函数来处理：

  • void *malloc(long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。
  • void free(void *firstbyte)：若是给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。

malloc_init 将是初始化内存分配程序的函数。它要完成如下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，而后创建起指向咱们管理的内存的指针。这三个变量都是全局变量：


清单 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 <unistd.h>
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;
 }

 

这就是咱们的内存管理器。如今，咱们只须要构建它，并在程序中使用它便可。

运行下面的命令来构建 malloc 兼容的分配程序（实际上，咱们忽略了 realloc() 等一些函数，不过， malloc() 和 free() 才是最主要的函数）：


清单 7. 编译分配程序

        
gcc -shared -fpic malloc.c -o malloc.so

 

该程序将生成一个名为 malloc.so 的文件，它是一个包含有咱们的代码的共享库。

在 UNIX 系统中，如今您能够用您的分配程序来取代系统的 malloc()，作法以下：


清单 8. 替换您的标准的 malloc

        
LD_PRELOAD=/path/to/malloc.so
export LD_PRELOAD

 

LD_PRELOAD 环境变量使动态连接器在加载任何可执行程序以前，先加载给定的共享库的符号。它还为特定库中的符号赋予优先权。所以，从如今起，该会话中的任何应用程序都将使用咱们的 malloc()，而不是只有系统的应用程序可以使用。有一些应用程序不使用 malloc()，不过它们是例外。其余使用 realloc() 等其余内存管理函数的应用程序，或者错误地假定 malloc() 内部行为的那些应用程序，极可能会崩溃。ash shell 彷佛可使用咱们的新 malloc() 很好地工做。

若是您想确保 malloc() 正在被使用，那么您应该经过向函数的入口点添加 write() 调用来进行测试。

咱们的内存管理器在不少方面都还存在欠缺，但它能够有效地展现内存管理须要作什么事情。它的某些缺点包括：

  • 因为它对系统中断点（一个全局变量）进行操做，因此它不能与其余分配程序或者 mmap 一块儿使用。
  • 当分配内存时，在最坏的情形下，它将不得不遍历 所有进程内存；其中可能包括位于硬盘上的不少内存，这意味着操做系统将不得不花时间去向硬盘移入数据和从硬盘中移出数据。
  • 没有很好的内存不足处理方案（ malloc 只假定内存分配是成功的）。
  • 它没有实现不少其余的内存函数，好比 realloc()。
  • 因为 sbrk() 可能会交回比咱们请求的更多的内存，因此在堆（heap）的末端会遗漏一些内存。
  • 虽然 is_available 标记只包含一位信息，但它要使用完整的 4-字节 的字。
  • 分配程序不是线程安全的。
  • 分配程序不能将空闲空间拼合为更大的内存块。
  • 分配程序的过于简单的匹配算法会致使产生不少潜在的内存碎片。
  • 我确信还有不少其余问题。这就是为何它只是一个例子!

其余 malloc 实现

malloc() 的实现有不少，这些实现各有优势与缺点。在设计一个分配程序时，要面临许多须要折衷的选择，其中包括：

  • 分配的速度。
  • 回收的速度。
  • 有线程的环境的行为。
  • 内存将要被用光时的行为。
  • 局部缓存。
  • 簿记（Bookkeeping）内存开销。
  • 虚拟内存环境中的行为。
  • 小的或者大的对象。
  • 实时保证。

每个实现都有其自身的优缺点集合。在咱们的简单的分配程序中，分配很是慢，而回收很是快。另外，因为它在使用虚拟内存系统方面较差，因此它最适于处理大的对象。

还有其余许多分配程序可使用。其中包括：

  • Doug Lea Malloc：Doug Lea Malloc 其实是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与咱们的版本很是相似的基本结构，可是它加入了索引，这使得搜索速度更快，而且能够将多个没有被使用的块组合为一个大的块。它还支持缓存，以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的 参考资料部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。
  • BSD Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 FreeBSD 之中，这个分配程序能够从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。因此，若是您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，可是可能会浪费内存。在 参考资料部分中，有一篇描述该实现的文章。
  • Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得很是快。所以，它的构造以锁的使用为中心，从而使全部进程没必要等待分配内存。它能够显著地加快那些进行不少分配和回收的多线程进程的速度。在 参考资料部分中，有一篇描述该实现的文章。

众多可用的分配程序中最有名的就是上述这些分配程序。若是您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，若是不熟悉分配程序的设计，那么定制分配程序一般会带来比它们解决的问题更多的问题。要得到关于该主题的适当的介绍，请参阅 Donald Knuth 撰写的 The Art of Computer Programming Volume 1: Fundamental Algorithms 中的第 2.5 节“Dynamic Storage Allocation”（请参阅 参考资料中的连接）。它有点过期，由于它没有考虑虚拟内存环境，不过大部分算法都是基于前面给出的函数。

在 C++ 中，经过重载 operator new()，您能够以每一个类或者每一个模板为单位实现本身的分配程序。在 Andrei Alexandrescu 撰写的 Modern C++ Design 的第 4 章（“Small Object Allocation”）中，描述了一个小对象分配程序（请参阅 参考资料中的连接）。

基于 malloc() 的内存管理的缺点

不仅是咱们的内存管理器有缺点，基于 malloc() 的内存管理器仍然也有不少缺点，无论您使用的是哪一个分配程序。对于那些须要保持长期存储的程序使用 malloc() 来管理内存可能会很是使人失望。若是您有大量的不固定的内存引用，常常难以知道它们什么时候被释放。生存期局限于当前函数的内存很是容易管理，可是对于生存期超出该范围的内存来讲，管理内存则困可贵多。并且，关于内存管理是由进行调用的程序仍是由被调用的函数来负责这一问题，不少 API 都不是很明确。

由于管理内存的问题，不少程序倾向于使用它们本身的内存管理规则。C++ 的异常处理使得这项任务更成问题。有时好像致力于管理内存分配和清理的代码比实际完成计算任务的代码还要多！所以，咱们将研究内存管理的其余选择。

回页首

半自动内存管理策略

引用计数

引用计数是一种 半自动（semi-automated）的内存管理技术，这表示它须要一些编程支持，可是它不须要您确切知道某一对象什么时候再也不被使用。引用计数机制为您完成内存管理任务。

在引用计数中，全部共享的数据结构都有一个域来包含当前活动“引用”结构的次数。当向一个程序传递一个指向某个数据结构指针时，该程序会将引用计数增长 1。实质上，您是在告诉数据结构，它正在被存储在多少个位置上。而后，当您的进程完成对它的使用后，该程序就会将引用计数减小 1。结束这个动做以后，它还会检查计数是否已经减到零。若是是，那么它将释放内存。

这样作的好处是，您没必要追踪程序中某个给定的数据结构可能会遵循的每一条路径。每次对其局部的引用，都将致使计数的适当增长或减小。这样能够防止在使用数据结构时释放该结构。不过，当您使用某个采用引用计数的数据结构时，您必须记得运行引用计数函数。另外，内置函数和第三方的库不会知道或者可使用您的引用计数机制。引用计数也难以处理发生循环引用的数据结构。

要实现引用计数，您只须要两个函数 —— 一个增长引用计数，一个减小引用计数并当计数减小到零时释放内存。

一个示例引用计数函数集可能看起来以下所示：


清单 9. 基本的引用计数函数

        
/* Structure Definitions*/
/* Base structure that holds a refcount */
struct refcountedstruct
{
	int refcount;
}
/* All refcounted structures must mirror struct
 * refcountedstruct for their first variables
 */
/* Refcount maintenance functions */
/* Increase reference count */
void REF(void *data)
{
	struct refcountedstruct *rstruct;
	rstruct = (struct refcountedstruct *) data;
	rstruct->refcount++;
}
/* Decrease reference count */
void UNREF(void *data)
{
	struct refcountedstruct *rstruct;
	rstruct = (struct refcountedstruct *) data;
	rstruct->refcount--;
	/* Free the structure if there are no more users */
	if(rstruct->refcount == 0)
	{
		free(rstruct);
	}
}

 

REF 和 UNREF 可能会更复杂，这取决于您想要作的事情。例如，您可能想要为多线程程序增长锁，那么您可能想扩展 refcountedstruct，使它一样包含一个指向某个在释放内存以前要调用的函数的指针（相似于面向对象语言中的析构函数 —— 若是您的结构中包含这些指针，那么这是 必需的）。

当使用 REF 和 UNREF 时，您须要遵照这些指针的分配规则：

  • UNREF 分配前左端指针（left-hand-side pointer）指向的值。
  • REF 分配后左端指针（left-hand-side pointer）指向的值。

在传递使用引用计数的结构的函数中，函数须要遵循如下这些规则：

  • 在函数的起始处 REF 每个指针。
  • 在函数的结束处 UNREF 第一个指针。

如下是一个使用引用计数的生动的代码示例：


清单 10. 使用引用计数的示例

        
/* EXAMPLES OF USAGE */
/* Data type to be refcounted */
struct mydata
{
	int refcount; /* same as refcountedstruct */
	int datafield1; /* Fields specific to this struct */
	int datafield2;
	/* other declarations would go here as appropriate */
};
/* Use the functions in code */
void dosomething(struct mydata *data)
{
	REF(data);
	/* Process data */
	/* when we are through */
	UNREF(data);
}
struct mydata *globalvar1;
/* Note that in this one, we don't decrease the
 * refcount since we are maintaining the reference
 * past the end of the function call through the
 * global variable
 */
void storesomething(struct mydata *data)
{
	REF(data); /* passed as a parameter */
	globalvar1 = data;
	REF(data); /* ref because of Assignment */
	UNREF(data); /* Function finished */
}

 

因为引用计数是如此简单，大部分程序员都自已去实现它，而不是使用库。不过，它们依赖于 malloc 和 free 等低层的分配程序来实际地分配和释放它们的内存。

在 Perl 等高级语言中，进行内存管理时使用引用计数很是普遍。在这些语言中，引用计数由语言自动地处理，因此您根本没必要担忧它，除非要编写扩展模块。因为全部内容都必须进行引用计数，因此这会对速度产生一些影响，但它极大地提升了编程的安全性和方便性。如下是引用计数的益处：

  • 实现简单。
  • 易于使用。
  • 因为引用是数据结构的一部分，因此它有一个好的缓存位置。

不过，它也有其不足之处：

  • 要求您永远不要忘记调用引用计数函数。
  • 没法释放做为循环数据结构的一部分的结构。
  • 减缓几乎每个指针的分配。
  • 尽管所使用的对象采用了引用计数，可是当使用异常处理（好比 try 或 setjmp()/ longjmp()）时，您必须采起其余方法。
  • 须要额外的内存来处理引用。
  • 引用计数占用告终构中的第一个位置，在大部分机器中最快能够访问到的就是这个位置。
  • 在多线程环境中更慢也更难以使用。

C++ 能够经过使用 智能指针（smart pointers）来容忍程序员所犯的一些错误，智能指针能够为您处理引用计数等指针处理细节。不过，若是不得不使用任何先前的不能处理智能指针的代码（好比对 C 库的联接），实际上，使用它们的后果通实比不使用它们更为困难和复杂。所以，它一般只是有益于纯 C++ 项目。若是您想使用智能指针，那么您实在应该去阅读 Alexandrescu 撰写的 Modern C++ Design 一书中的“Smart Pointers”那一章。

内存池

内存池是另外一种半自动内存管理方法。内存池帮助某些程序进行自动内存管理，这些程序会经历一些特定的阶段，并且每一个阶段中都有分配给进程的特定阶段的内存。例如，不少网络服务器进程都会分配不少针对每一个链接的内存 —— 内存的最大生存期限为当前链接的存在期。Apache 使用了池式内存（pooled memory），将其链接拆分为各个阶段，每一个阶段都有本身的内存池。在结束每一个阶段时，会一次释放全部内存。

在池式内存管理中，每次内存分配都会指定内存池，从中分配内存。每一个内存池都有不一样的生存期限。在 Apache 中，有一个持续时间为服务器存在期的内存池，还有一个持续时间为链接的存在期的内存池，以及一个持续时间为请求的存在期的池，另外还有其余一些内存池。所以，若是个人一系列函数不会生成比链接持续时间更长的数据，那么我就能够彻底从链接池中分配内存，并知道在链接结束时，这些内存会被自动释放。另外，有一些实现容许注册 清除函数（cleanup functions），在清除内存池以前，刚好能够调用它，来完成在内存被清理前须要完成的其余全部任务（相似于面向对象中的析构函数）。

要在本身的程序中使用池，您既可使用 GNU libc 的 obstack 实现，也可使用 Apache 的 Apache Portable Runtime。GNU obstack 的好处在于，基于 GNU 的 Linux 发行版本中默认会包括它们。Apache Portable Runtime 的好处在于它有不少其余工具，能够处理编写多平台服务器软件全部方面的事情。要深刻了解 GNU obstack 和 Apache 的池式内存实现，请参阅 参考资料部分中指向这些实现的文档的连接。

下面的假想代码列表展现了如何使用 obstack：


清单 11. obstack 的示例代码

        
#include <obstack.h>
#include <stdlib.h>
/* Example code listing for using obstacks */
/* Used for obstack macros (xmalloc is
   a malloc function that exits if memory
   is exhausted */
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
/* Pools */
/* Only permanent allocations should go in this pool */
struct obstack *global_pool;
/* This pool is for per-connection data */
struct obstack *connection_pool;
/* This pool is for per-request data */
struct obstack *request_pool;
void allocation_failed()
{
	exit(1);
}
int main()
{
	/* Initialize Pools */
	global_pool = (struct obstack *)
		xmalloc (sizeof (struct obstack));
	obstack_init(global_pool);
	connection_pool = (struct obstack *)
		xmalloc (sizeof (struct obstack));
	obstack_init(connection_pool);
	request_pool = (struct obstack *)
		xmalloc (sizeof (struct obstack));
	obstack_init(request_pool);
	/* Set the error handling function */
	obstack_alloc_failed_handler = &allocation_failed;
	/* Server main loop */
	while(1)
	{
		wait_for_connection();
		/* We are in a connection */
		while(more_requests_available())
		{
			/* Handle request */
			handle_request();
			/* Free all of the memory allocated
			 * in the request pool
			 */
			obstack_free(request_pool, NULL);
		}
		/* We're finished with the connection, time
		 * to free that pool
		 */
		obstack_free(connection_pool, NULL);
	}
}
int handle_request()
{
	/* Be sure that all object allocations are allocated
	 * from the request pool
	 */
	int bytes_i_need = 400;
	void *data1 = obstack_alloc(request_pool, bytes_i_need);
	/* Do stuff to process the request */
	/* return */
	return 0;
}

 

基本上，在操做的每个主要阶段结束以后，这个阶段的 obstack 会被释放。不过，要注意的是，若是一个过程须要分配持续时间比当前阶段更长的内存，那么它也可使用更长期限的 obstack，好比链接或者全局内存。传递给 obstack_free() 的 NULL 指出它应该释放 obstack 的所有内容。能够用其余的值，可是它们一般不怎么实用。

使用池式内存分配的益处以下所示：

  • 应用程序能够简单地管理内存。
  • 内存分配和回收更快，由于每次都是在一个池中完成的。分配能够在 O(1) 时间内完成，释放内存池所需时间也差很少（其实是 O(n) 时间，不过在大部分状况下会除以一个大的因数，使其变成 O(1)）。
  • 能够预先分配错误处理池（Error-handling pools），以便程序在常规内存被耗尽时仍能够恢复。
  • 有很是易于使用的标准实现。

池式内存的缺点是：

  • 内存池只适用于操做能够分阶段的程序。
  • 内存池一般不能与第三方库很好地合做。
  • 若是程序的结构发生变化，则不得不修改内存池，这可能会致使内存管理系统的从新设计。
  • 您必须记住须要从哪一个池进行分配。另外，若是在这里出错，就很难捕获该内存池。

回页首

垃圾收集

垃圾收集（Garbage collection）是全自动地检测并移除再也不使用的数据对象。垃圾收集器一般会在当可用内存减小到少于一个具体的阈值时运行。一般，它们以程序所知的可用的一组“基本”数据 —— 栈数据、全局变量、寄存器 —— 做为出发点。而后它们尝试去追踪经过这些数据链接到每一块数据。收集器找到的都是有用的数据；它没有找到的就是垃圾，能够被销毁并从新使用这些无用的数据。为了有效地管理内存，不少类型的垃圾收集器都须要知道数据结构内部指针的规划，因此，为了正确运行垃圾收集器，它们必须是语言自己的一部分。

收集器的类型

  • 复制（copying）： 这些收集器将内存存储器分为两部分，只容许数据驻留在其中一部分上。它们定时地从“基本”的元素开始将数据从一部分复制到另外一部分。内存新近被占用的部分如今成为活动的，另外一部分上的全部内容都认为是垃圾。另外，当进行这项复制操做时，全部指针都必须被更新为指向每一个内存条目的新位置。所以，为使用这种垃圾收集方法，垃圾收集器必须与编程语言集成在一块儿。
  • 标记并清理（Mark and sweep）：每一块数据都被加上一个标签。不按期的，全部标签都被设置为 0，收集器从“基本”的元素开始遍历数据。当它遇到内存时，就将标签标记为 1。最后没有被标记为 1 的全部内容都认为是垃圾，之后分配内存时会从新使用它们。
  • 增量的（Incremental）：增量垃圾收集器不须要遍历所有数据对象。由于在收集期间的忽然等待，也由于与访问全部当前数据相关的缓存问题（全部内容都不得不被页入（page-in）），遍历全部内存会引起问题。增量收集器避免了这些问题。
  • 保守的（Conservative）：保守的垃圾收集器在管理内存时不须要知道与数据结构相关的任何信息。它们只查看全部数据类型，并假定它们 能够所有都是指针。因此，若是一个字节序列能够是一个指向一块被分配的内存的指针，那么收集器就将其标记为正在被引用。有时没有被引用的内存会被收集，这样会引起问题，例如，若是一个整数域中包含一个值，该值是已分配内存的地址。不过，这种状况极少发生，并且它只会浪费少许内存。保守的收集器的优点是，它们能够与任何编程语言相集成。

Hans Boehm 的保守垃圾收集器是可用的最流行的垃圾收集器之一，由于它是免费的，并且既是保守的又是增量的，可使用 --enable-redirect-malloc 选项来构建它，而且能够将它用做系统分配程序的简易替代者（drop-in replacement）（用 malloc/ free 代替它本身的 API）。实际上，若是这样作，您就可使用与咱们在示例分配程序中所使用的相同的 LD_PRELOAD 技巧，在系统上的几乎任何程序中启用垃圾收集。若是您怀疑某个程序正在泄漏内存，那么您可使用这个垃圾收集器来控制进程。在早期，当 Mozilla 严重地泄漏内存时，不少人在其中使用了这项技术。这种垃圾收集器既能够在 Windows® 下运行，也能够在 UNIX 下运行。

垃圾收集的一些优势：

  • 您永远没必要担忧内存的双重释放或者对象的生命周期。
  • 使用某些收集器，您可使用与常规分配相同的 API。

其缺点包括：

  • 使用大部分收集器时，您都没法干涉什么时候释放内存。
  • 在多数状况下，垃圾收集比其余形式的内存管理更慢。
  • 垃圾收集错误引起的缺陷难于调试。
  • 若是您忘记将再也不使用的指针设置为 null，那么仍然会有内存泄漏。

回页首

结束语

一切都须要折衷：性能、易用、易于实现、支持线程的能力等，这里只列出了其中的一些。为了知足项目的要求，有不少内存管理模式能够供您使用。每种模式都有大量的实现，各有其优缺点。对不少项目来讲，使用编程环境默认的技术就足够了，不过，当您的项目有特殊的须要时，了解可用的选择将会有帮助。下表对比了本文中涉及的内存管理策略。

表 1. 内存分配策略的对比

策略 分配速度 回收速度 局部缓存 易用性 通用性 实时可用 SMP 线程友好
定制分配程序 取决于实现 取决于实现 取决于实现 很难 无 取决于实现 取决于实现
简单分配程序 内存使用少时较快 很快 差 容易 高 否 否
GNU malloc 中 快 中 容易 高 否 中
Hoard 中 中 中 容易 高 否 是
引用计数 N/A N/A 很是好 中 中 是（取决于 malloc 实现） 取决于实现
池 中 很是快 极好 中 中 是（取决于 malloc 实现） 取决于实现
垃圾收集 中（进行收集时慢） 中 差 中 中 否 几乎不
增量垃圾收集 中 中 中 中 中 否 几乎不
增量保守垃圾收集 中 中 中 容易 高 否 几乎不

参考资料

  • 您能够参阅本文在 developerWorks 全球站点上的 英文原文。

Web 上的文档

基本的分配程序

池式分配程序

智能指针和定制分配程序

  • Loki C++ Library 有不少为 C++ 实现的通用模式，包括智能指针和一个定制的小对象分配程序。

垃圾收集器

关于现代操做系统中的虚拟内存的文章

关于 malloc 的文章

关于定制分配程序的文章

关于垃圾收集的文章

Web 上的通用参考资料

书籍

来自 developerWorks

    • 自我管理数据缓冲区内存 （developerWorks，2004 年 1 月）略述了一个用于管理内存的自管理的抽象数据缓存器的伪 C （pseudo-C）实现。

    • A framework for the user defined malloc replacement feature （developerWorks，2002 年 2 月）展现了如何利用 AIX 中的一个工具，使用本身设计的内存子系统取代原有的内存子系统。

    • 掌握 Linux 调试技术 （developerWorks，2002 年 8 月）描述了可使用调试方法的 4 种不一样情形：段错误、内存溢出、内存泄漏和挂起。

    • 在 处理 Java 程序中的内存漏洞 （developerWorks，2001 年 2 月）中，了解致使 Java 内存泄漏的缘由，以及什么时候须要考虑它们。

    • 在 developerWorks Linux 专区中，能够找到更多为 Linux 开发人员准备的参考资料。

    • 从 developerWorks 的 Speed-start your Linux app 专区中，能够下载运行于 Linux 之上的 IBM 中间件产品的免费测试版本，其中包括 WebSphere® Studio Application Developer、WebSphere Application Server、DB2® Universal Database、Tivoli® Access Manager 和 Tivoli Directory Server，查找 how-to 文章和技术支持。

    • 经过参与 developerWorks blogs 加入到 developerWorks 社区。

    • 能够在 Developer Bookstore Linux 专栏中定购 打折出售的 Linux 书籍。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程