如何减少malloc分配的内存碎片（怎样设计一个内存池，减少内存碎片）

本文目录

• 怎样设计一个内存池，减少内存碎片
• linux 系统mysql 服务器内存利用率很高了怎么解决
• 编程经验谈:如何正确使用内存
• C语言中怎样清空内存动态分配的堆空间
• 内存碎片的减少内存碎片
• C语言里是不是free（）函数只能用来释放通过malloc建立的内存空间
• Linux用户进程是如何释放内存的

怎样设计一个内存池，减少内存碎片

　　一般工程里不推荐你写，因为你费力写一个出来99%可能性没有内置的好，且内存出bug难调试
　　一定要设计的话，你也可以当个玩具写写玩玩：
　　1. 实现教科书上的内存分配器：
　　做一个链表指向空闲内存，分配就是取出一块来，改写链表，返回，释放就是放回到链表里面，并做好归并。注意做好标记和保护，避免二次释放，还可以花点力气在如何查找最适合大小的内存快的搜索上，减少内存碎片，有空你了还可以把链表换成伙伴算法，写着玩嘛。
　　2. 实现固定内存分配器：
　　即实现一个 FreeList，每个 FreeList 用于分配固定大小的内存块，比如用于分配 32字节对象的固定内存分配器，之类的。每个固定内存分配器里面有两个链表，OpenList 用于存储未分配的空闲对象，CloseList用于存储已分配的内存对象，那么所谓的分配就是从 OpenList 中取出一个对象放到 CloseList 里并且返回给用户，释放又是从 CloseList 移回到 OpenList。分配时如果不够，那么就需要增长 OpenList：申请一个大一点的内存块，切割成比如 64 个相同大小的对象添加到 OpenList中。这个固定内存分配器回收的时候，统一把先前向系统申请的内存块全部还给系统。
　　3. 实现 FreeList 池：
　　在你实现了 FreeList的基础上，按照不同对象大小（8字节，16字节，32，64，128，256，512，1K。。。64K），构造十多个固定内存分配器，分配内存时根据内存大小查表，决定到底由哪个分配器负责，分配后要在头部的 header 处（ptr处）写上 cookie，表示又哪个分配器分配的，这样释放时候你才能正确归还。如果大于64K，则直接用系统的 malloc作为分配，如此以浪费内存为代价你得到了一个分配时间近似O（1）的内存分配器，差不多实现了一个 memcached 的 slab 内存管理器了，但是先别得意。此 slab 非彼 slab（sunos/solaris/linux kernel 的 slab）。这说白了还是一个弱智的 freelist 无法归还内存给操作系统，某个 FreeList 如果高峰期占用了大量内存即使后面不用，也无法支援到其他内存不够的 FreeList，所以我们做的这个和 memcached 类似的分配器其实是比较残缺的，你还需要往下继续优化。
　　4. 实现正统的 slab （非memcached的伪 slab）代替 FreeList：
　　这时候你需要阅读一下论文了，现代内存分配技术的基础，如何管理 slab 上的对象，如何进行地址管理，如何管理不同 slab 的生命周期，如何将内存回收给系统。然后开始实现一个类似的东西，文章上传统的 slab 的各种基础概念虽然今天没有改变，但是所用到的数据结构和控制方法其实已经有很多更好的方法了，你可以边实现边思考下，实在不行还可以参考 kernel 源码嘛。但是有很多事情应用程序做不了，有很多实现你是不能照搬的，比如页面提供器，可以提供连续线性地址的页面，再比如说 kernel 本身记录着每个页面对应的 slab，你查找 slab 时，系统其实是根据线性地址移位得到页面编号，然后查表得到的，而你应用程序不可能这么干，你还得做一些额外的体系来解决这些问题，还需要写一些额外的 cookie 来做标记。做好内存收缩工作，内存不够时先收缩所有分配器的 slab，再尝试重新分配。再做好内存回收工作，多余的内存，一段时间不使用可以还给操作系统。
　　5. 实现混合分配策略：
　　你实现了上面很多常见的算法后，该具体阅读各种内存分配器的代码了，这些都是经过实践检验的，比如 libc 的内存分配器，或者参考有自带内存管理的各种开源项目，比如 python 源码，做点实验对比他们的优劣，然后根据分配对象的大小采用不同的分配策略，区别对待各种情况。试验的差不多了就得引入多线程支持了，将你的锁改小。注意很多系统层的线程安全策略你是没法弄的，比如操作系统可以关中断，短时间内禁止本cpu发生任务切换，这点应用程序就很麻烦了，还得用更小的锁来代替。当锁已经小到不能再小，也可以选择引入 STM 来代替各种链表的锁。
　　6. 实现 Per-CPU Cache：
　　现代内存分配器，在多核下的一个重要优化就是给多核增加 cache，为了进一步避免多线程锁竞争，需要引入 Per-CPU Cache 了。分配内存先找到对应线程所在的cpu，从该cpu上对应的 cache 里分配，cache 不够了就一次性从你底层的内存分配器里多分配几个对象进来填充 cache，释放时也是先放回 cache，cache里面如果对象太多，就做一次收缩，把内存换个底层分配器，让其他 cpu 的cache有机会利用。这样针对很多短生命周期的频繁的分配、释放，其实都是在 cache 里完成的，没有锁竞争，同时cache分配逻辑简单，速度更快。操作系统里面的代码经常是直接读取当前的cpu是哪个，而应用层实现你可以用 thread local storage 来代替，目前这些东西在 crt的 malloc 里还暂时支持不到位（不排除未来版本会增加），可以更多参考 tc/jemalloc。
　　7. 实现地址着色:
　　现代内存分配器必须多考虑总线压力，在很多机型上，如果内存访问集中在某条 cache line相同的偏移上，会给总线带来额外的负担和压力。比如你经常要分配一个 FILE 对象，而每个 FILE对象使用时会比较集中的访问 int FILE::flag; 这个成员变量，如果你的页面提供器提供的页面地址是按照 4K对齐的，那么很可能多个 FILE对象的 flag 成员所处的 cache line 偏移地址是相同的，大量访问这些相同的偏移地址会给总线带来很大负担，这时候你需要给每个对象额外增加一些偏移，让他们能够均匀的分布在线性地址对应的cache line 偏移上，消减总线冲突的开销。
　　8. 优化缓存竞争：
　　多核时代，很多单核时代的代码都需要针对性的优化改写，最基本的一条就是 cache 竞争，这是比前面锁竞争更恶劣的情况：如果两个cpu同时访问相同的 cache-line 或者物理页面，那么 cpu 之间为了保证内存一致性会做很多的通信工作，比如那个cpu0需要用到这段内存，发现cpu1也在用，那么需要通知cpu1，将cpu1 L1-L2缓存里面的数据写回该物理内存，并且释放控制权，这时cpu0取得了控制权才能继续操作，期间cpu0-cpu1之间的通信协议是比较复杂的，代价也是比较大的，cache竞争比锁竞争恶劣不少。为了避免 cache 竞争，需要比先前Per-CPU cache 更彻底的 Per-CPU Page 机制来解决，直接让不同的cpu使用不同的页面进行二次分配，彻底避免 cache 竞争。具体应用层的做法也是利用线性地址来判断所属页面（因为物理页面映射到进程地址也是4k对齐的），同时继续使用 thread local storage 或者用系统提供的 api 读取当前属于哪个 cpu 来实现。为了避免核太多每个核占据大量的页面带来的不必要的浪费，你可以参考下 Linux 最新的 slub 内存分配算法，但是 slub 也有未尽之处，好几个 linux 发行版在实践中发现 slub 还是存在一些问题的（非bug，而是机制），所以大部分发行版默认都是关闭 slub 的，虽然，你还是可以借鉴测试一下。
　　9. 调试和折腾：
　　继续参考各种现代内存分配器，取长补短，然后给你的分配器添加一些便于调试的机制，方便诊断各种问题。在你借鉴了很多开源项目，自己也做了一些所谓的优化，折腾了那么久以后，你或许以为你的分配器可以同各种开源分配器一战了，测试效果好像也挺好的，先别急，继续观察内存利用率，向操作系统申请/归还内存的频率等一系列容易被人忽视的指标是否相同。同时更换你的测试用例，看看更多的情况下，是否结果还和先前一样？这些都差不多的时候，你发现没有个一两年的大规模持续使用，你很难发现一些潜在的隐患和bug，可能你觉得没问题的代码，跑了两年后都会继续报bug，这很正常，多点耐心，兴许第三年以后就比较稳定了呢？

linux 系统mysql 服务器内存利用率很高了怎么解决

Linux 进程通过 C 标准库中的内存分配函数 malloc 向系统申请内存，但是到真正与内核交互之间，其实还隔了一层，即内存分配管理器(memory allocator)。常见的内存分配器包括：ptmalloc(Glibc)、tcmalloc(Google)、jemalloc(FreeBSD)。MySQL 默认使用的是 glibc 的 ptmalloc 作为内存分配器。

内存分配器采用的是内存池的管理方式，处在用户程序层和内核层之间，它响应用户的分配请求，向操作系统申请内存，然后将其返回给用户程序。

为了保持高效的分配，分配器通常会预先向操作系统申请一块内存，当用户程序申请和释放内存的时候，分配器会将这些内存管理起来，并通过一些算法策略来判断是否将其返回给操作系统。这样做的最大好处就是可以避免用户程序频繁的调用系统来进行内存分配，使用户程序在内存使用上更加高效快捷。

关于 ptmalloc 的内存分配原理，个人也不是非常了解，这里就不班门弄斧了，有兴趣的同学可以去看下华庭的《glibc 内存管理 ptmalloc 源代码分析》【文末链接】。

关于如何选择这三种内存分配器，网上资料大多都是推荐摒弃 glibc 原生的 ptmalloc，而改用 jemalloc 或者 tcmalloc 作为默认分配器。因为 ptmalloc 的主要问题其实是内存浪费、内存碎片、以及加锁导致的性能问题，而 jemalloc 与 tcmalloc 对于内存碎片、多线程处理优化的更好。

目前 jemalloc 应用于 Firefox、FaceBook 等，并且是 MariaDB、Redis、Tengine 默认推荐的内存分配器，而 tcmalloc 则应用于 WebKit、Chrome 等。

编程经验谈:如何正确使用内存

　　　　首先我们要了解内存的分配方式。一般来说，内存的分配方式有三种：　　　　1．从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
　　　　2．在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
　　3．从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
　　　　以上三种分配方式，我们要注意内存生命期的问题：　　　　1．静态分配的区域的生命期是整个软件运行期，就是说从软件运行开始到软件终止退出。只有软件终止运行后，这块内存才会被系统回收　　　　2．在栈中分配的空间的生命期与这个变量所在的函数和类相关。如果是函数中定义的局部变量，那么它的生命期就是函数被调用时，如果函数运行结束，那么这块内存就会被回收。如果是类中的成员变量，则它的生命期与类实例的生命期相同　　　　3．在堆上分配的内存，生命期是从调用new或者malloc开始，到调用delete或者free结束。如果不掉用delete或者free。则这块空间必须到软件运行结束后才能被系统回收。
　　　　　　发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。
　　　　常见的内存错误及其对策如下：　　　　1 内存分配未成功，却使用了它。
　　　　编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p!=NULL)进行防错处理。
　　　　2 内存分配虽然成功，但是尚未初始化就引用它。
　　　　犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初值错误（例如数组）。
　　　　3 内存分配成功并且已经初始化，但操作越过了内存的边界。
　　　　例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。
　　　　4 忘记了释放内存，造成内存泄露。
　　　　含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。
　　　　动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。
　　　　5 释放了内存却继续使用它。
　　　　有三种情况：　　　　（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
　　　　

C语言中怎样清空内存动态分配的堆空间

在C语言中，要在堆上分配空间，需要使用内存申请函数。一般用malloc。
void * malloc(int size);
可以申请一段长度为size字节的空间，并返回空间的首地址。
要清空分配的内存空间，也就是将该空间所有字节均赋值为0，可以使用memset函数。
该函数声明与string.h中，形式为
void memset(void *start, int value, int size);
如果要清空空间的首地址为p，大小为len，则可以调用
memset(p, 0, len);

内存碎片的减少内存碎片

内存碎片是因为在分配一个内存块后，使之空闲，但不将空闲内存归还给最大内存块而产生的。最后这一步很关键。如果内存分配程序是有效的，就不能阻止系统分配内存块并使之空闲。即使一个内存分配程序不能保证返回的内存能与最大内存块相连接（这种方法可以彻底避免内存碎片问题），但你可以设法控制并限制内存碎片。所有这些作法涉及到内存块的分割。每当系统减少被分割内存块的数量，确保被分割内存块尽可能大时，你就会有所改进。
这样做的目的是尽可能多次反复使用内存块，而不要每次都对内存块进行分割，以正好符合请求的存储量。分割内存块会产生大量的小内存碎片，犹如一堆散沙。以后很难把这些散沙与其余内存结合起来。比较好的办法是让每个内存块中都留有一些未用的字节。留有多少字节应看系统要在多大程度上避免内存碎片。对小型系统来说，增加几个字节的内部碎片是朝正确方向迈出的一步。当系统请求1字节内存时，你分配的存储量取决于系统的工作状态。
如果系统分配的内存存储量的主要部分是 1 ～ 16 字节，则为小内存也分配 16 字节是明智的。只要限制可以分配的最大内存块，你就能够获得较大的节约效果。但是，这种方法的缺点是，系统会不断地尝试分配大于极限的内存块，这使系统可能会停止工作。减少最大和最小内存块存储量之间内存存储量的数量也是有用的。采用按对数增大的内存块存储量可以避免大量的碎片。例如，每个存储量可能都比前一个存储量大 20%。在嵌入式系统中采用“一种存储量符合所有需要”对于嵌入式系统中的内存分配程序来说可能是不切实际的。这种方法从内部碎片来看是代价极高的，但系统可以彻底避免外部碎片，达到支持的最大存储量。
将相邻空闲内存块连接起来是一种可以显著减少内存碎片的技术。如果没有这一方法，某些分配算法（如最先适合算法）将根本无法工作。然而，效果是有限的，将邻近内存块连接起来只能缓解由于分配算法引起的问题，而无法解决根本问题。而且，当内存块存储量有限时，相邻内存块连接可能很难实现。
有些内存分配器很先进，可以在运行时收集有关某个系统的分配习惯的统计数据，然后，按存储量将所有的内存分配进行分类，例如分为小、中和大三类。系统将每次分配指向被管理内存的一个区域，因为该区域包括这样的内存块存储量。较小存储量是根据较大存储量分配的。这种方案是最先适合算法和一组有限的固定存储量算法的一种有趣的混合，但不是实时的。
有效地利用暂时的局限性通常是很困难的，但值得一提的是，在内存中暂时扩展共处一地的分配程序更容易产生内存碎片。尽管其它技术可以减轻这一问题，但限制不同存储量内存块的数目仍是减少内存碎片的主要方法。
现代软件环境业已实现各种避免内存碎片的工具。例如，专为分布式高可用性容错系统开发的 OSE 实时操作系统可提供三种运行时内存分配程序：内核 alloc()，它根据系统或内存块池来分配；堆 malloc()，根据程序堆来分配； OSE 内存管理程序 alloc_region，它根据内存管理程序内存来分配。
从 许多方面来看，Alloc就是终极内存分配程序。它产生的内存碎片很少，速度很快，并有判定功能。你可以调整甚至去掉内存碎片。只是在分配一个存储量后，使之空闲，但不再分配时，才会产生外部碎片。内部碎片会不断产生，但对某个给定的系统和八种存储量来说是恒定不变的。
Alloc 是一种有八个自由表的固定存储量内存分配程序的实现方法。系统程序员可以对每一种存储量进行配置，并可决定采用更少的存储量来进一步减少碎片。除开始时以外，分配内存块和使内存块空闲都是恒定时间操作。首先，系统必须对请求的存储量四舍五入到下一个可用存储量。就八种存储量而言，这一目标可用三个 如果 语句来实现。其次，系统总是在八个自由表的表头插入或删除内存块。开始时，分配未使用的内存要多花几个周期的时间，但速度仍然极快，而且所花时间恒定不变。
堆 malloc() 的内存开销（8 ～ 16 字节/分配）比 alloc小，所以你可以停用内存的专用权。malloc() 分配程序平均来讲是相当快的。它的内部碎片比alloc()少，但外部碎片则比alloc()多。它有一个最大分配存储量，但对大多数系统来说，这一极限值足够大。可选的共享所有权与低开销使 malloc() 适用于有许多小型对象和共享对象的 C++ 应用程序。堆是一种具有内部堆数据结构的伙伴系统的实现方法。在 OSE 中，有 28 个不同的存储量可供使用，每种存储量都是前两种存储量之和，于是形成一个斐波那契（Fibonacci）序列。实际内存块存储量为序列数乘以 16 字节，其中包括分配程序开销或者 8 字节/分配（在文件和行信息启用的情况下为 16 字节）。
当你很少需要大块内存时，则OSE内存管理程序最适用。典型的系统要把存储空间分配给整个系统、堆或库。在有 MMU 的系统中，有些实现方法使用 MMU 的转换功能来显著降低甚至消除内存碎片。在其他情况下，OSE 内存管理程序会产生非常多的碎片。它没有最大分配存储量，而且是一种最先适合内存分配程序的实现方法。内存分配被四舍五入到页面的偶数——典型值是 4 k 字节。

C语言里是不是free（）函数只能用来释放通过malloc建立的内存空间

如果不适用free释放内存，会造成内存泄露。随着程序的运行，程序所占内存越来越多，知道系统奔溃或者程序结束。

1、free函数：

原型：void free(void *ptr)；

功能：释放malloc(或calloc、realloc)函数给指针变量分配的动态内存；

头文件：malloc.h或stdlib.h；

2、为了避免释放已经释放了内存的指针内存，或没有释放内存，在C语言中最好是在定义指针时赋初值NULL，释放后立即赋NULL，释放时检查指针值再决定释放就避免释放错误了，例如：

int *a = NULL

int *b = (int*) malloc(sizeof(int) * 10);

a= b;

/* 执行大量操作后 */

if(a != NULL) {free(a);a=NULL;}

if(b != NULL) {free(b);b=NULL;}

Linux用户进程是如何释放内存的

从图中我们可以看出，进程的堆，并不是直接建立在Linux的内核的内存分配策略上的，而是建立在glibc的堆管理策略上的（也就是glibc的动态内存分配策略上），堆的管理是由glibc进行的。所以我们调用free对mal
Linux进程使用内存的基本流程：
从图中我们可以看出，进程的堆，并不是直接建立在Linux的内核的内存分配策略上的，而是建立在glibc的堆管理策略上的（也就是glibc的动态内存分配策略上），堆的管理是由glibc进行的。所以我们调用free对malloc得到的内存进行释放的时候，并不是直接释放给操作系统，而是还给了glibc的堆管理实体，而glibc会在把实际的物理内存归还给系统的策略上做一些优化，以便优化用户任务的动态内存分配过程。
它会从堆的最大线性地址开始，从后向前计算用户任务当前有多少空闲的堆内存（直到碰到使用中的堆内存地址为止），比如在该图中:
它会认为有2048k的可释放内存，只有在该值大于某个特定的threshhold时（2.3.6上为64k），它才会把这些内存归还给系统。而在中间的未使用内存是不会归还给系统的，所以系统也不可能再利用这块物理内存页（我们假设系统没有swap区和swap文件），也就是说系统的内存会为此减少，除非在它之前的堆内存都用free进行释放以后，glibc的堆管理器才有可能（只是有可能）把该段内存归还给系统。