不定长内存池之apr_pool

逃离我推掉我的手 2022-03-28 16:46 380阅读 0赞

内存池可有效降低动态申请内存的次数，减少与内核态的交互，提升系统性能，减少内存碎片，增加内存空间使用率，避免内存泄漏的可能性，这么多的优点，没有理由不在系统中使用该技术。

内存池分类：

1、 不定长内存池。典型的实现有apr\_pool、obstack。优点是不需要为不同的数据类型创建不同的内存池，缺点是造成分配出的内存不能回收到池中。这是由于这种方案以session为粒度，以业务处理的层次性为设计基础。

2、 定长内存池。典型的实现有LOKI、BOOST。特点是为不同类型的数据结构分别创建内存池，需要内存的时候从相应的内存池中申请内存，优点是可以在使用完毕立即把内存归还池中，可以更为细粒度的控制内存块。  
与变长的相比，这种类型的内存池更加通用，另一方面对于大量不同的数据类型环境中，会浪费不少内存。但一般系统主要的数据结构都不会很多，并且都是重复申请释放使用，这种情况下，定长内存池的这点小缺点可以忽略了。

一、apr

apr 是 apache 使用的底层库，apache 是跨平台的，其跨平台正是基于 apr。个人觉得，使用apr有两个好处，一是不用担心跨平台（事实上，我从来就不担心，因为我写的程序，从来都不跨平台）。二是 apr 的 pool 很好用。pool 有两个好处，一是可以理解成内存池，在 pool上 分配的内存，是不用释放的，pool 销毁的时候自然会释放这些内存（所以销毁（清理）pool变得异常重要，千万不能忘了）。二是可以理解成资源管理器，分配资源后，然后在pool上注册一个释放资源的函数，pool 销毁（清理）的时候，会调用这个函数，释放资源。例如打开了一个文件，可以在 pool 上注册一个关闭文件的函数，让 pool 替你关闭文件。也可以在不销毁（清理）pool 时，手动的释放。具体可以看参考[apr手册][apr]。

APR的核心就是Apache的资源管理（池），我们将在本章的后面部分进行更加详细的介绍。表3-1列出了APR中的所有模块。

表3-1 APR模块

<table> 
 <thead> 
 <tr> 
 <td> 名称 </td> 
 <td> 目的 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td> apr_allocator </td> 
 <td> 内存分配，内部使用 </td> 
 </tr> 
 <tr> 
 <td> apr_atomic </td> 
 <td> 原子操作 </td> 
 </tr> 
 <tr> 
 <td> apr_dso </td> 
 <td> 动态加载代码（.so/.dll） </td> 
 </tr> 
 <tr> 
 <td> apr_env </td> 
 <td> 读取/设定环境变量 </td> 
 </tr> 
 <tr> 
 <td> apr_errno </td> 
 <td> 定义错误条件和宏 </td> 
 </tr> 
 <tr> 
 <td> apr_file_info </td> 
 <td> 文件系统对象和路径的属性 </td> 
 </tr> 
 <tr> 
 <td> apr_file_io </td> 
 <td> 文件系统输入/输出 </td> 
 </tr> 
 <tr> 
 <td> apr_fnmatch </td> 
 <td> 文件系统模式匹配 </td> 
 </tr> 
 <tr> 
 <td> apr_general </td> 
 <td> 初始化/终结，有用的宏 </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
 <tr> 
 <td> 名称 </td> 
 <td> 目的 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td> apr_getopt </td> 
 <td> 命令参数 </td> 
 </tr> 
 <tr> 
 <td> apr_global_mutex </td> 
 <td> 全局锁 </td> 
 </tr> 
 <tr> 
 <td> apr_hash </td> 
 <td> 哈希表 </td> 
 </tr> 
 <tr> 
 <td> apr_inherit </td> 
 <td> 文件句柄继承助手 </td> 
 </tr> 
 <tr> 
 <td> apr_lib </td> 
 <td> 奇数和末端 </td> 
 </tr> 
 <tr> 
 <td> apr_mmap </td> 
 <td> 内存映射 </td> 
 </tr> 
 <tr> 
 <td> apr_network_io </td> 
 <td> 网络输入/输出（套接字） </td> 
 </tr> 
 <tr> 
 <td> apr_poll </td> 
 <td> 投票 </td> 
 </tr> 
 <tr> 
 <td> apr_pools </td> 
 <td> 资源管理 </td> 
 </tr> 
 <tr> 
 <td> apr_portable </td> 
 <td> APR到本地映射转换 </td> 
 </tr> 
 <tr> 
 <td> apr_proc_mutex </td> 
 <td> 进程锁 </td> 
 </tr> 
 <tr> 
 <td> apr_random </td> 
 <td> 随机数 </td> 
 </tr> 
 <tr> 
 <td> apr_ring </td> 
 <td> 环数据结构和宏 </td> 
 </tr> 
 <tr> 
 <td> apr_shm </td> 
 <td> 共享内存 </td> 
 </tr> 
 <tr> 
 <td> apr_signal </td> 
 <td> 信号处理 </td> 
 </tr> 
 <tr> 
 <td> apr_strings </td> 
 <td> 字符串操作 </td> 
 </tr> 
 <tr> 
 <td> apr_support </td> 
 <td> 内部支持函数 </td> 
 </tr> 
 <tr> 
 <td> apr_tables </td> 
 <td> 表格和数组函数 </td> 
 </tr> 
 <tr> 
 <td> apr_thread_cond </td> 
 <td> 线程条件 </td> 
 </tr> 
 <tr> 
 <td> apr_thread_mutex </td> 
 <td> 线程锁 </td> 
 </tr> 
 <tr> 
 <td> apr_thread_proc </td> 
 <td> 线程和进程函数 </td> 
 </tr> 
 <tr> 
 <td> apr_thread_rwlock </td> 
 <td> 读写锁 </td> 
 </tr> 
 <tr> 
 <td> apr_time </td> 
 <td> 时间/日期函数 </td> 
 </tr> 
 <tr> 
 <td> apr_user </td> 
 <td> 用户和组ID服务 </td> 
 </tr> 
 <tr> 
 <td> apr_version </td> 
 <td> APR版本 </td> 
 </tr> 
 <tr> 
 <td> apr_want </td> 
 <td> 标准头文件支持 </td> 
 </tr> 
 </tbody> 
</table>

表3-2 APU模块

<table> 
 <tbody> 
 <tr> 
 <td> 名称 </td> 
 <td> 目的 </td> 
 </tr> 
 <tr> 
 <td> apr_anylock </td> 
 <td> 透明的、任何锁的封装 </td> 
 </tr> 
 <tr> 
 <td> apr_base64 </td> 
 <td> Base-64编码 </td> 
 </tr> 
 <tr> 
 <td> apr_buckets </td> 
 <td> Buckets/Bucket brigade </td> 
 </tr> 
 <tr> 
 <td> apr_date </td> 
 <td> 时间字符串解析 </td> 
 </tr> 
 <tr> 
 <td> apr_dbd </td> 
 <td> 针对SQL数据库的常用API </td> 
 </tr> 
 <tr> 
 <td> apr_dbm </td> 
 <td> 针对DBM数据库的常用API </td> 
 </tr> 
 <tr> 
 <td> apr_hooks </td> 
 <td> 钩子实现宏 </td> 
 </tr> 
 <tr> 
 <td> apr_ldap </td> 
 <td> LDAP授权API </td> 
 </tr> 
 <tr> 
 <td> apr_ldap_init </td> 
 <td> LDAP初始化API，主要应用在和LDAP服务器的初始安全连接 </td> 
 </tr> 
 <tr> 
 <td> apr_ldap_option </td> 
 <td> 设置LDAP选项的API </td> 
 </tr> 
 <tr> 
 <td> apr_ldap_url </td> 
 <td> 解析和处理LDAP URL的API </td> 
 </tr> 
 <tr> 
 <td> apr_md4 </td> 
 <td> MD4编码 </td> 
 </tr> 
 <tr> 
 <td> apr_md5 </td> 
 <td> MD5编码 </td> 
 </tr> 
 <tr> 
 <td> apr_optional </td> 
 <td> 可选函数 </td> 
 </tr> 
 <tr> 
 <td> apr_optional_hooks </td> 
 <td> 可选钩子 </td> 
 </tr> 
 <tr> 
 <td> apr_queue </td> 
 <td> 线程安全的FIFO队列 </td> 
 </tr> 
 <tr> 
 <td> apr_reslist </td> 
 <td> 资源池 </td> 
 </tr> 
 <tr> 
 <td> apr_rmm </td> 
 <td> 可再定位地址的内存 </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td colspan="2"> 名称 </td> 
 <td> 目的 </td> 
 </tr> 
 <tr> 
 <td> apr_sdbm </td> 
 <td colspan="2"> SDBM库 </td> 
 </tr> 
 <tr> 
 <td> apr_sha1 </td> 
 <td colspan="2"> SHA1编码 </td> 
 </tr> 
 <tr> 
 <td> apr_strmatch </td> 
 <td colspan="2"> 字符串模式匹配 </td> 
 </tr> 
 <tr> 
 <td> apr_uri </td> 
 <td colspan="2"> URI解析/构造 </td> 
 </tr> 
 <tr> 
 <td> apr_uuid </td> 
 <td colspan="2"> 用户标识 </td> 
 </tr> 
 <tr> 
 <td> apr_xlate </td> 
 <td colspan="2"> 字符集转换（I18N） </td> 
 </tr> 
 <tr> 
 <td> apr_xml </td> 
 <td colspan="2"> XML解析 </td> 
 </tr> 
 <tr> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

基本的约定

APR和APR-UTIL采用了一些约定，使得它们的API具有同质性，并且易于使用。

3.3.1 参考手册：API文档和Doxygen

APR和APU在代码层都有非常好的文档。每一个公开函数和数据类型都在定义它们的头文件中进行了注释，使用了doxygen友好的格式。那些头文件，或者doxygen生成的文档，为程序员提供了完整的API参考手册。如果你安装了doxygen，那么就可以通过make dox命令从源代码中生成你自己版本的APR参考手册。

3.3.2 命名空间

所有的APR和APU的公开接口都使用了字符串前缀“apr\_”（数据类型和函数）和“APR\_”（宏），这就为APR定义了一个“保留”的命名空间。

在APR命名空间中，绝大部分的APR和APU模块使用了二级命名空间。这个约定通常基于正在讨论的那个模块的名字。例如，模块apr\_dbd中的所有函数使用字符串“apr\_dbd\_”前缀。有时候使用一个明显的描述性的二级命名空间。例如，在模块apr\_network\_io中套接字操作使用“apr\_socket\_”前缀。

3.3.3 声明的宏

APR和APU的公开函数使用类似于APR\_DECLARE、APU\_DECLARE和APR\_ DECLARE\_NONSTD的宏进行声明。例如：

APR\_DECLARE(apr\_status\_t) apr\_initialize(void);

在很多的平台上，这是一个空声明，并且扩展为

apr\_status\_t apr\_initialize(void);

例如在Windows的Visual C++平台上，需要使用它们自己的、非标准的关键字，例如“\_dllexport”来允许其他的模块使用一个函数，这些宏就需要扩展以适应这些需要的关键字。

3.3.4 apr\_status\_t和返回值

在APR和APU中广泛采用的一个约定是：函数返回一个状态值，用来为调用者指示成功或者是返回一个错误代码。这个类型是apr\_status\_t，在apr\_errno.h中定义，并赋予整数值。因此一个APR函数的常见原型就是：

APR\_DECLARE(apr\_status\_t) apr\_do\_something(…function args…);

返回值应当在逻辑上进行判断，并且实现一个错误处理函数（进行回复或者对错误进行进一步的描述）。返回值APR\_SUCCESS意味着成功，我们通常可以用如下的方式进行错误处理结构：

apr\_status\_t rv;  
...  
rv = apr\_do\_something(... args ...);  
if (rv != APR\_SUCCESS) \{  
/\* 记录一个错误 \*/  
return rv;  
\}

有时候我们可能需要做得更多。例如，如果do\_something是一个非闭塞的I/O操作并且返回APR\_EAGAIN，我们可能需要重试这个操作。  
有些函数返回一个字符串（char \*或者const char \*）、一个void \*或者void。这些函数就被认为在没有失败条件或者在错误发生时返回一个空指针。

3.3.5 条件编译

本质上说，APR的一些特色可能并不是每个平台都支持的。例如，FreeBSD在5.x版本之前并没有适合Apache的本地线程实现，因此线程在APR中就不被支持（除非编译时手动设置相应的操作）。

为了在这种情况下应用程序依然能够工作，APR为这些情况提供了APR\_HAS\_\*宏。如果一个应用处于这种情况，它应当使用这些宏进行条件编译。例如，一个模块执行了一个操作，这个操作可能导致在多线程环境下的竞争条件，那么它就可能使用以下的方式。

\#if APR\_HAS\_THREADS  
rv = apr\_thread\_mutex\_lock(mutex);  
if (rv != APR\_SUCCESS) \{  
/\* 记录一个错误 \*/  
/\* 放弃关键的操作\*/  
\}  
\#endif

/\* ... 在这里执行关键代码... \*/

\#if APR\_HAS\_THREAD  
apr\_thread\_mutex\_unlock(mutex);  
\#endif

二、apr\_pool内存池。

pool本身并不直接从物理内存中分配或释放,而是通过allocator(内存分配器)来统一管理,可以为新池创建新的allocator(内存分配器),但通常使用默认的全局allocator(内存分配器),这样更有助于统一的内存管理。pool采用的是树形的结构,在初始化内存池(apr\_pool\_initialize)时,建立根池,和全局allocator(内存分配器),以后建立的都是根结点的子孙结点可以从pool中分配任何大小的内存块,但释放的单位为pool,就是说pool释放之前,从pool分配出的内存不能单独释放,看起来好像有点浪费。这里要注意的是，有些分配的内存块，清除时有特别操作,这样就需要要带清除函数，在分配之后用apr\_pool\_cleanup\_register注册清除时用的函数。特殊的，如果内存块里是线程对象，也不能用一般的清除函数，应该用apr\_pool\_note\_subprocess注册清除操作。

apr\_pool中主要有3个对象，allocator、pool、block。pool从allocator申请内存，pool销毁的时候把内存归还allocator，allocator销毁的时候把内存归还给系统，allocator有一个owner成员，是一个pool对象，allocator的owner销毁的时候，allocator被销毁。在apr\_pool中并无block这个单词出现，这里大家可以把从pool从申请的内存称为block，使用apr\_palloc申请block，block只能被申请，没有释放函数，只能等pool销毁的时候才能把内存归还给allocator，用于allocator以后的pool再次申请。

常见函数：

对系统内存池初始化,全局的,一个进程只要初始化一次

apr\_status\_t apr\_pool\_initialize (void)

销毁内存池对象,及内部的结构和子内存池

void apr\_pool\_terminate (void)

创建一个新的内存池

apr\_status\_t apr\_pool\_create\_ex (apr\_pool\_t \*\*newpool, apr\_pool\_t \*parent, apr\_abortfunc\_t abort\_fn, apr\_allocator\_t \*allocator)

创建一个新的内存池,apr\_pool\_create\_ex的使用默认参数简化版

apr\_status\_t apr\_pool\_create (apr\_pool\_t \*\*newpool, apr\_pool\_t \*parent)

获取内存池使用的内存分配器

apr\_allocator\_t \* apr\_pool\_allocator\_get (apr\_pool\_t \*pool)

清除一个内存池的内容,清除后内容为空，但可以再使用

void apr\_pool\_clear (apr\_pool\_t \*p)

释构一个内存池

void apr\_pool\_destroy (apr\_pool\_t \*p)

从池中分配内存

void \* apr\_palloc (apr\_pool\_t \*p, apr\_size\_t size)

从池中分配内存,并将分配出来的内存置0

void \* apr\_pcalloc (apr\_pool\_t \*p, apr\_size\_t size)

设置内存分配出错时的调用函数

void apr\_pool\_abort\_set (apr\_abortfunc\_t abortfunc, apr\_pool\_t \*pool)

获取内存分配出错时的调用函数

apr\_abortfunc\_t apr\_pool\_abort\_get (apr\_pool\_t \*pool)

获取池的父池

apr\_pool\_t \* apr\_pool\_parent\_get (apr\_pool\_t \*pool)

判断a是否是b的祖先

int apr\_pool\_is\_ancestor (apr\_pool\_t \*a, apr\_pool\_t \*b)

为内存池做标签

void apr\_pool\_tag (apr\_pool\_t \*pool, const char \*tag)

设置与当前池关联的数据

apr\_status\_t apr\_pool\_userdata\_set (const void \*data, const char \*key, apr\_status\_t(\*cleanup)(void \*), apr\_pool\_t \*pool)

设置与当前池关联的数据,与apr\_pool\_userdata\_set类似,但内部不拷贝数据的备份,如常量字符串时就有用

apr\_status\_t apr\_pool\_userdata\_setn (const void \*data, const char \*key, apr\_status\_t(\*cleanup)(void \*), apr\_pool\_t \*pool)

获取与当前池关联的数据

apr\_status\_t apr\_pool\_userdata\_get (void \*\*data, const char \*key, apr\_pool\_t \*pool)

注册内存块的清除函数，每块销毁时要特别处理的都要注册下，在cleanups里加入一个项

void apr\_pool\_cleanup\_register (apr\_pool\_t \*p, const void \*data, apr\_status\_t(\*plain\_cleanup)(void \*), apr\_status\_t(\*child\_cleanup)(void \*))

删除内存块的清除函数，从cleanups里移除一个项，放入free\_cleanups中

void apr\_pool\_cleanup\_kill (apr\_pool\_t \*p, const void \*data, apr\_status\_t(\*cleanup)(void \*))

用新的child\_cleanup，替换原来老的child\_cleanup

void apr\_pool\_child\_cleanup\_set (apr\_pool\_t \*p, const void \*data, apr\_status\_t(\*plain\_cleanup)(void \*), apr\_status\_t(\*child\_cleanup)(void \*))

执行内存块的清除函数，进从清除函数的队列cleanups中删除

apr\_status\_t apr\_pool\_cleanup\_run (apr\_pool\_t \*p, void \*data, apr\_status\_t(\*cleanup)(void \*))

一个空的内存块清除函数

apr\_status\_t apr\_pool\_cleanup\_null (void \*data)

执行所有的子清除函数child\_cleanup

void apr\_pool\_cleanup\_for\_exec (void)

带调试信息内存池函数,功能跟上面的一样，只是多了调试信息

apr\_status\_t apr\_pool\_create\_ex\_debug (apr\_pool\_t \*\*newpool, apr\_pool\_t \*parent, apr\_abortfunc\_t abort\_fn, apr\_allocator\_t \*allocator, const char \*file\_line)

void apr\_pool\_clear\_debug (apr\_pool\_t \*p, const char \*file\_line)

void apr\_pool\_destroy\_debug (apr\_pool\_t \*p, const char \*file\_line)

void \* apr\_palloc\_debug (apr\_pool\_t \*p, apr\_size\_t size, const char \*file\_line)

void \* apr\_pcalloc\_debug (apr\_pool\_t \*p, apr\_size\_t size, const char \*file\_line)

一般可以不调用创建allocator的函数，而是使用的默认全局allocator。但是apr\_pool提供了一系列函数操作allocator，可以自己调用这些函数：

apr\_allocator\_create

apr\_allocator\_destroy

apr\_allocator\_alloc

apr\_allocator\_free 创建销毁allocator

apr\_allocator\_owner\_set

apr\_allocator\_owner\_get 设置获取owner

apr\_allocator\_max\_free\_set 设置pool销毁的时候内存是否直接归还到操作系统的阈值