[导读] 前文描述了栈的基本概念，本文来聊聊堆是怎么会事儿。RT-Thread 在社区广受欢迎，阅读了其内核代码，实现了堆的管理，代码设计很清晰，可读性很好。故一方面了解RT-Thread内核实现，一方面可以弄清楚其堆的内部实现。将学习体会记录分享，希望对于堆的理解及实现有一个更深入的认知。

注，文中代码分析基于rt-thread-v4.0.2 版本。

什么是堆？

C语言堆是由malloc(),calloc(),realloc()等函数动态获取内存的一种机制。使用完成后，由程序员调用free()等函数进行释放。使用时，需要包含stdlib.h头文件。

C++预言的堆管理则是使用new操作符向堆管理器申请动态内存分配，使用delete操作符将使用完毕内存的释放给堆管理器。

注：本文只描述C的堆管理器实现相关内容。

以C语言为例，将上面的描述，翻译成一个图：

要动态管理一片内存，且需要动态分配释放，这样一个需求。很显然C语言需要将动态内存区抽象描述起来并实现动态管理。事实上，C语言中堆管理器其本质是利用数据结构将堆区抽象描述，所需要描述的方面：

• 可用于分配的内存
• 正在使用的内存块
• 释放掉的内存块
  & m8 Z1 t/ b: `. S) M* D

再利用相应算法对于这类数据结构对象进行动态管理而实现的堆管理器。

**经常看到各种算法书很多只讲算法原理，而不讲应用实例，往往体会不深。私以为可以做些改善。学而不能致用，何必费力去学。所以不是晦涩难懂的算法无用，而是没有去真正结合应用。可以再进一步想，如果算法没有应用场景，也一定会在技术发展的历程中逐渐被世人遗忘。所以建议学习阅读算法书籍时，找些实例来看看，一定会加深对算法的理解领悟。**这是比较重要的题外话，送给大家以共勉。

所以从本质上讲，堆管理器就是数据结构+算法实现的动态内存管理器，管理内存的动态分配以及释放。

: c" b. Z0 g) N" Q* R" C, T为什么要堆？

C编程语言对内存管理方式有静态，自动或动态三种方式。静态内存分配的变量通常与程序的可执行代码一起分配在主存储器中，并在程序的整个生命周期内有效。自动分配内存的变量在栈上分配，并随着函数的调用和返回而申请或释放。对于静态分配内存和自动分配内存的生命周期，分配的大小必须是编译时常量（可变长度自动数组[5]除外）。如果所需的内存大小直到运行时才知道（例如，如果要从用户或磁盘文件中读取任意大小的数据），则使用固定大小的数据对象则满足不了要求了。试想，即便假定都知道要多大内存，如在windows/Linux下有那么多应用程序，每个应用程序加载时都将运行中所需的内存采样静态分配策略，则如多个程序运行内存将很快耗尽。

分配的内存的生命周期也可能引起关注。静态或自动分配都不能满足所有情况。自动分配内存不能在多个函数调用之间保留，而静态数据在程序的整个生命周期中必然保留，无论是否真正需要（所以都采用这样的策略必然造成浪费）。在许多情况下，程序员在管理分配的内存的生命周期具有更多的灵活性。

通过使用动态内存分配则避免了这些限制/缺点，在动态内存分配中，更明确（但更灵活）地管理内存，通常是通过从免费存储区（非正式地称为“堆”）中分配内存（为此目的而构造的内存区域）进行分配的。在C语言中，库函数malloc用于在堆上分配一个内存块。程序通过malloc返回的指针访问该内存块。当不再需要内存时，会将指针传递给free，从而释放内存，以便可以将其用于其他目的。

谁实现堆

如果一问道这个问题，马上会说C编译器。不错C编译器实现了堆管理器，而事实上并非编译器在编译的过程中实现动态内存管理器，而是C编译器所实现的C库实现了堆管理器，比如ANSI C，VC, IAR C编译器，GNU C等其实都需要一些C库的支持，那么这些库的内部就隐藏了这么一个堆管理器。眼见为实吧，还是以IAR ARM 8.40.1 为例，其堆管理器就实现在：

.\IAR Systems\Embedded Workbench 8.3\arm\src\lib\dlib\heap

一看有这么多的源码，那么对于应用开发而言，有哪些选项需要进行配置呢？

支持四个选项：

• Automatic：
  
  • 如果您的应用程序中有对堆内存分配例程的调用，但没有对堆释放例程的调用，则链接程序将自动选择无空闲堆。
  • 如果您的应用程序中有对堆内存分配例程的调用，则链接程序会自动选择高级堆。
  • 例如，如果在库中调用了堆内存分配例程，则链接程序会自动选择基本堆。
    
• Advanced heap:高级堆（--advanced_heap）为广泛使用该堆的应用程序提供有效的内存管理。特别是，重复分配和释放内存的应用程序可能会在空间和时间上获得较少的开销。高级堆的代码明显大于基本堆的代码。
• Basic heap: 基本堆（--basic_heap）是一个简单的堆分配器，适用于不经常使用堆的应用程序。特别是，它可以用于仅分配堆内存而从不释放堆内存的应用程序中。基本堆并不是特别快，并且在反复释放内存的应用程序中使用它很可能导致不必要的堆碎片化。基本堆的代码远小于高级堆的大小。
• No-free heap:无可用堆（--no_free_heap）使用此选项可以使用最小的堆实现。因为此堆不支持释放或重新分配，所以它仅适用于在启动阶段为各种缓冲区分配堆内存的应用程序，以及永不释放内存的应用程序。
  

但是如果认为仅仅标准C库负责实现堆管理器，则这种理解并不全面。回到事物的本质，堆管理器是利用数据结构及算法动态管理一片内存的分配与释放。那么有这样需求的地方，都可能需要实现一个堆管理器。

堆管理器的实现很大程度取决于操作系统以及硬件体系架构。大体上需要实现堆内存管理器的有两大类：

• 应用程序，应用程序需要堆内存管理器，是显而易见的。比如常见的windows/Linux下的应用程序，都需要堆内存管理器。而上述的cortex M或者其他单片机程序使用C/C++编程时都需要堆内存管理器。
• 操作系统内核，操作系统内核需要像应用程序一样分配内存。但是，内核中malloc的实现通常与C库使用的实现有很大不同。例如，内存缓冲区可能需要符合DMA施加的特殊限制，或者可能从中断上下文中调用内存分配功能。这需要与操作系统内核的虚拟内存子系统紧密集成的malloc实现。比如Linux内核就需要实现内核版本的堆管理器，对外提供kmalloc/vmalloc申请内存，kfree/vfree用于释放内存。
  ! R/ B, F7 h( f' F

怎么实现堆

对于RT-Thread的内核而言，也实现了一个内核堆管理器，这里就来梳理一下RT-Thread内核版本的小堆管理器的实现，同时来了解一下链表数据结构及算法操作的实例应用。

其堆管理器实现位于.\rt-thread-v4.0.2\rt-thread\src下mem.c，memheap.c以及mempool.c。

关键数据结构

其堆管理器主要的数据结构为heap_mem。

• heap_mem
  
  
  
  * Z9 c* K0 l: P( i# l2 H+ v

堆管理器初始化

堆管理器的初始化入口在mem.c，函数为：

void rt_system_heap_init(void *begin_addr, void *end_addr)
{
    struct heap_mem *mem;
    /*按4字节对齐转换地址*/
: r3 y0 x7 w, r% s    /*如0x2000 0001～0x2000 0003,转后为0x2000 0004*/
    rt_ubase_t begin_align = RT_ALIGN((rt_ubase_t)begin_addr, RT_ALIGN_SIZE);
    /*如0x3000 0001～0x3000 0003,转后为0x3000 0000*/
& p& J' T. C' W- s  W    rt_ubase_t end_align   = RT_ALIGN_DOWN((rt_ubase_t)end_addr, RT_ALIGN_SIZE);
   
! U/ o  c! q1 H1 C+ Q    /*调试信息，函数不可用于中断内部*/
    RT_DEBUG_NOT_IN_INTERRUPT;
1 ^3 E7 r! h# c8 m
% w, A% Y0 n) x    /* 分配地址范围至少能存储两个heap_mem */
6 m! b# @5 D5 `8 @    if ((end_align > (2 * SIZEOF_STRUCT_MEM)) &&
        ((end_align - 2 * SIZEOF_STRUCT_MEM) >= begin_align))
    {
6 u! q4 [1 ]3 _. ?! w1 v        /* 计算可用堆区，4字节对齐 */
        mem_size_aligned = end_align - begin_align - 2 * SIZEOF_STRUCT_MEM;
$ D; |' U1 N/ G% e    }
# a, y2 ]2 L* E7 v. ~    else
- H% A5 E: |/ r3 j    {
        rt_kprintf("mem init, error begin address 0x%x, and end address 0x%x\n",
                   (rt_ubase_t)begin_addr, (rt_ubase_t)end_addr);
) v5 V, G7 E4 S& Q- p
8 u4 h, i/ W# ^$ e; s        return;
    }
+ j% N9 S5 s3 g- g( t/ x9 _( _0 r1 n+ q% @
9 Z( g- W! R" S- Q" m0 \8 K    /* heap_ptr指向堆区起始地址 */
, d1 g! x& y* J5 t    heap_ptr = (rt_uint8_t *)begin_align;

    RT_DEBUG_LOG(RT_DEBUG_MEM, ("mem init, heap begin address 0x%x, size %d\n",
                                (rt_ubase_t)heap_ptr, mem_size_aligned));
4 B. I- B& g2 J, J  i% G' }; V
& m$ |  ~! Z( Y5 _+ W7 ^' k; _    /* 初始化堆起始描述符 */
/ ^/ \( e# U  V4 C    mem        = (struct heap_mem *)heap_ptr;
    mem->magic = HEAP_MAGIC;
+ |9 d- z7 c5 _5 @% `    mem->next  = mem_size_aligned + SIZEOF_STRUCT_MEM;
    mem->prev  = 0;
    mem->used  = 0;
#ifdef RT_USING_MEMTRACE
+ L- c# t1 t5 u% h; p    rt_mem_setname(mem, "INIT");
: F' b8 q" J! j. b9 M#endif
& U) G9 C% O4 G; {  r6 k
    /* 初始化堆结束描述符 */
) g  j, n0 W) C    heap_end        = (struct heap_mem *)&heap_ptr[mem->next];
- f. z9 _0 L  ^    heap_end->magic = HEAP_MAGIC;
    heap_end->used  = 1;
4 ~' O: {$ ]- x6 Q( H    heap_end->next  = mem_size_aligned + SIZEOF_STRUCT_MEM;
    heap_end->prev  = mem_size_aligned + SIZEOF_STRUCT_MEM;
#ifdef RT_USING_MEMTRACE
& C: H, S  V7 I    rt_mem_setname(heap_end, "INIT");
#endif

    rt_sem_init(&heap_sem, "heap", 1, RT_IPC_FLAG_FIFO);

; f# r3 X, @0 B! M5 u" r% I    /* 初始化释放指针指向堆的开始 */
    lfree = (struct heap_mem *)heap_ptr;
}
; m2 }" l' {# H4 a

传入链接堆区的内存起始地址，以及结束地址。以STM32为例，传入0x20000000--0x20018000，96k字节

上述rt_system_heap_init( 0x20000000,0x20018000)，主要做了下图这么一件事情。

将堆管理头尾描述符进行了初始化，并指向对应的内存地址。用图翻译一下：

技巧点：

• 利用类型强制转换将内存数据转换为struct heap_mem *。实现了静态双链表的创建
  ( {* R/ Z8 I& Z; U+ N5 ^5 s

mem      = (struct heap_mem *)heap_ptr;
5 }+ @) I$ p6 x8 cheap_end = (struct heap_mem *)&heap_ptr[mem->next];
1 _" ~1 }5 o. g0 a- i

• 定义heap_mem没有定义使用多少字节为该块的用户数据字节数，节约了内存。是一个比较好的处理方式。
• 对齐方式可配置，RT_ALIGN_SIZE默认为4字节。
  
  # ^$ e* r  y: i

向堆申请内存

用户调用rt_malloc 用于申请分配动态内存。

void *rt_malloc(rt_size_t size)
{
1 A% |+ E/ a- K) O    rt_size_t ptr, ptr2;
    struct heap_mem *mem, *mem2;
/ f2 b$ Q9 Q- d8 `/ G4 ^! x
4 Q: n4 x( H6 `  m3 e6 v    if (size == 0)
        return RT_NULL;

    RT_DEBUG_NOT_IN_INTERRUPT;
& v: a7 P0 J8 q& @: p4 R& W0 L    /*按四字节对齐申请，如申请5字节，则实际按8字节申请*/
+ S/ v8 v7 b) n; h    if (size != RT_ALIGN(size, RT_ALIGN_SIZE))
9 q% n) @' p$ y2 f' |        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d, but align to %d\n",
                                    size, RT_ALIGN(size, RT_ALIGN_SIZE)));
    else
        RT_DEBUG_LOG(RT_DEBUG_MEM, ("malloc size %d\n", size));
5 d6 f2 i" o1 D2 D
- P: [3 W& \) h( V( w, Z7 j    /* 按四字节对齐申请，如申请5字节，则实际按8字节申请 */
    size = RT_ALIGN(size, RT_ALIGN_SIZE);

7 [" N% U! l9 n6 @    if (size > mem_size_aligned)
+ j/ K0 [0 S6 O' r! X  a( ]    {
        RT_DEBUG_LOG(RT_DEBUG_MEM, ("no memory\n"));
        return RT_NULL;
    }

    /* 每块的长度必须至少为MIN_SIZE_ALIGNED=12 STM32*/
    if (size < MIN_SIZE_ALIGNED)
        size = MIN_SIZE_ALIGNED;

    /* 获取堆保护信号量 */
/ _! l4 B$ D4 ?1 e+ q    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);

2 |$ n# F9 Y' Y: U    for (ptr = (rt_uint8_t *)lfree - heap_ptr;
+ N: @( Y* Y$ H6 Q' k         ptr < mem_size_aligned - size;
  {! J  j7 V  B- m- z         ptr = ((struct heap_mem *)&heap_ptr[ptr])->next)
- g1 M" t! f* b: Y$ e8 A    {
        mem = (struct heap_mem *)&heap_ptr[ptr];
5 _3 t0 _/ d# }+ w' M% z
$ M- T7 S$ a6 X& Q- o, K        /*如果该块未使用，且满足大小要求*/
        if ((!mem->used) && (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size)
1 [4 a. X: F" u. W4 C0 s4 y! j. H2 t        {
            /* mem没有被使用，至少完美的配合是可能的:
% @' N  g$ B$ @1 a' u             * mem->next - (ptr + SIZEOF_STRUCT_MEM) 计算出mem的“用户数据大小” */
* d0 ?* O6 S3 M* a3 L            if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >=
                (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED))
1 G  ?  O$ @4 t" M            {
                /* (除了上面的，我们测试另一个结构heap_mem (SIZEOF_STRUCT_MEM)
                 * 是否包含至少MIN_SIZE_ALIGNED的数据也适合'mem'的'用户数据空间')
                 * -> 分割大的块，创建空的余数,
# K  j2 b0 \% p  I( v2 W$ v                 * 余数必须足够大，以包含MIN_SIZE_ALIGNED大小数据:
. P& ?1 K) u- ?& C: ~, J9 z1 f- N                 * 如果mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size,
7 }# Y. O& V9 S+ F" E1 [7 q$ |                 * struct heap_mem 会适合，在mem2及mem2->next没有使用
                 */
                ptr2 = ptr + SIZEOF_STRUCT_MEM + size;

                /* create mem2 struct */
                mem2       = (struct heap_mem *)&heap_ptr[ptr2];
: U/ `2 _% ]" T+ G3 w7 ]                mem2->magic = HEAP_MAGIC;
                mem2->used = 0;
                mem2->next = mem->next;
4 q. q' L8 P9 i5 e                mem2->prev = ptr;
#ifdef RT_USING_MEMTRACE
, F! `, ?( ^. _9 H. l4 D' v; E                rt_mem_setname(mem2, "    ");
#endif
                /*将ptr2插入mem及mem->next之间 */
! Q# X8 p* F6 N$ u/ z1 L, e                mem->next = ptr2;
                mem->used = 1;
9 M( ?/ z- E1 t# H% q9 F9 a) M
                if (mem2->next != mem_size_aligned + SIZEOF_STRUCT_MEM)
                {
                    ((struct heap_mem *)&heap_ptr[mem2->next])->prev = ptr2;
                }
#ifdef RT_MEM_STATS
                used_mem += (size + SIZEOF_STRUCT_MEM);
1 Y; f' D& U! t+ d; |9 M) X( T$ K                if (max_mem < used_mem)
7 g$ y0 T5 o; d/ X2 I                    max_mem = used_mem;
#endif
# G* N* m( s1 l* i) p* [* ]7 I            }
            else
5 @# l1 \) ^$ n, N            {
                mem->used = 1;
% V% F( ~$ \$ r& d  _) l5 _#ifdef RT_MEM_STATS
* t9 P( k, I, J& x! e! B) [) ~                used_mem += mem->next - ((rt_uint8_t *)mem - heap_ptr);
$ U& t! R& H" s% D6 X! l  W                if (max_mem < used_mem)
                    max_mem = used_mem;
#endif
            }
            /* 设置块幻数 */
            mem->magic = HEAP_MAGIC;
#ifdef RT_USING_MEMTRACE
            if (rt_thread_self())
                rt_mem_setname(mem, rt_thread_self()->name);
# R& S* ?1 ]+ Y' e            else
                rt_mem_setname(mem, "NONE");
( e) W* z6 ~; o3 a#endif
& T* t* K) A" i' L# [' G
2 t) w7 v" `1 ]            if (mem == lfree)
            {
- [$ l6 t* ], P' w& k5 J                /* 寻找下一个空闲块并更新lfree指针*/
                while (lfree->used && lfree != heap_end)
5 m1 U  W4 i( Z1 J: p                    lfree = (struct heap_mem *)&heap_ptr[lfree->next];
" m1 G- g7 o: g5 L; k1 l* Q
- m. ]& }8 H) Z5 ?1 x! C) p4 H                RT_ASSERT(((lfree == heap_end) || (!lfree->used)));
7 ]! K& s& U( r; L" v            }
/ U+ j  H# C5 f" o( u, O
            rt_sem_release(&heap_sem);
            RT_ASSERT((rt_ubase_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_ubase_t)heap_end);
: ~* ]3 A% X% b            RT_ASSERT((rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
            RT_ASSERT((((rt_ubase_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);

; L) g3 ~- P7 S/ D% e8 V, Z3 |3 P$ f            RT_DEBUG_LOG(RT_DEBUG_MEM,
2 g+ Y9 a; J( E' M0 s                         ("allocate memory at 0x%x, size: %d\n",
                          (rt_ubase_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM),
3 s+ W  u' @8 ^& G  X                          (rt_ubase_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));

            RT_OBJECT_HOOK_CALL(rt_malloc_hook,
                                (((void *)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM)), size));

            /* 返回除mem结构之外的内存地址 */
6 U- q; _% a7 F, l2 W; ~            return (rt_uint8_t *)mem + SIZEOF_STRUCT_MEM;
        }
    }
$ K8 `/ }  }$ q+ Y, H, Y2 P, d6 M    /* 释放堆保护信号量 */
    rt_sem_release(&heap_sem);
$ C! @# M) z) z- u( ]1 s
    return RT_NULL;
}

其基本思路，从空闲块链表开始检索内存块，如检索到某块空闲且满足申请大小且其剩余空间至少能存储描述符，则满足了申请要求，则将后续内存头部生成描述，更新前后指针，标记幻数以及块已被使用标记，将该块插入链表。返回申请成功的内存地址。如果检索不到，则返回空指针，表示申请失败，堆目前没有满足要求的内存可供使用。实际上，上述代码在运行时将堆内存区按照下述示意图进行动态维护。

概括一下：

• heap_ptr总是指向堆起始地址，heap_end总是指向最后一个块，两者配合可以实现边界保护，在释放内存时使用。
• lfree 总是指向最地址最小的空闲块，因此在动态申请内存时，总是从该块进行检索是否有满足申请要求的内存块可供使用。
• used=1表示该块被占用，非空闲。used=0表示该块空闲。
• magic 字段幻数，起始就是一个特殊标记字，与used=0配合，用于检测异常，试想一下如果仅仅用used=0判断块是空闲，则易出错，或者需要加其他的辅助代码，才能保证代码的健壮性。
• 动态内存管理申请比较慢，需要检索链表，以及额外的内存开销。
• rt_realloc 及rt_calloc 不做分析了
  

释放内存

释放内存由rt_free实现：

void rt_free(void *rmem)
{
& D. o, i+ H# h6 B    struct heap_mem *mem;

2 X" p: b9 y0 W  f7 e) `    if (rmem == RT_NULL)
- V8 I4 Q" m" z8 a1 _, K; J+ i        return;

    RT_DEBUG_NOT_IN_INTERRUPT;
8 ]' g+ ]' f% ]. ]" W. ?: @
    RT_ASSERT((((rt_ubase_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
    RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
              (rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);

    RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem));
, f. q$ R; U2 J: W6 e; q    /* 申请释放地址不在堆区 */
/ Q) h3 ?; E) ?( b* b! ~    if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr ||
        (rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end)
    {
& \# m6 M/ P" u; a" `  r        RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n"));
4 |* \# _  {1 M0 L6 e
' Q. t5 @4 F! J" b( y, R1 [* d        return;
    }
$ I& c) j& @1 w2 Y
4 T: T8 w! a. N- I& _8 q! r    /* 获取块描述符 */
    mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM);
( {2 d3 p- Q8 c) d  O3 k/ `* E
- X/ g' s( g/ \    RT_DEBUG_LOG(RT_DEBUG_MEM,
                 ("release memory 0x%x, size: %d\n",
# g. W3 J" F6 @3 s                  (rt_ubase_t)rmem,
                  (rt_ubase_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr))));
  x& ^( {- d/ u8 @# A2 k3 X

    /* 获取堆保护信号量 */
    rt_sem_take(&heap_sem, RT_WAITING_FOREVER);
4 d! D, u+ K7 e" M9 I
5 F3 Y2 J1 C0 K& k% O, G/ u) X    /* 待释放的内存，其块描述符需是使用状态 */
    if (!mem->used || mem->magic != HEAP_MAGIC)
    {
        rt_kprintf("to free a bad data block:\n");
& P9 I$ p% {2 G* w; c        rt_kprintf("mem: 0x%08x, used flag: %d, magic code: 0x%04x\n", mem, mem->used, mem->magic);
    }
0 O* S7 Q; ]! O* B  ~    RT_ASSERT(mem->used);
) m% d% X' o6 l- q2 T    RT_ASSERT(mem->magic == HEAP_MAGIC);
) ]% A+ t; s8 J4 v! i: z    /* 清除使用标志 */
" E  }9 ]! t0 _8 g    mem->used  = 0;
8 {7 M1 o' E, i0 B! ]4 d; A    mem->magic = HEAP_MAGIC;
#ifdef RT_USING_MEMTRACE
# W$ D* R/ b9 E; X: ?    rt_mem_setname(mem, "    ");
#endif

    if (mem < lfree)
3 m4 ^0 m& d, f    {
        /* 更新空闲块lfree指针 */
        lfree = mem;
    }

#ifdef RT_MEM_STATS
1 p/ r( C- B* b    used_mem -= (mem->next - ((rt_uint8_t *)mem - heap_ptr));
5 C. U- z- t5 d- }' h: u$ Z#endif
* g' j- a. T  V6 ~
+ J* r9 j! n! e9 m- k8 {3 |    /* 如临近块也处于空闲态，则合并整理成一个更大的块 */
) O# l9 R0 Y% j0 b# l    plug_holes(mem);
2 q" h* @8 R2 u% u    rt_sem_release(&heap_sem);
}
RTM_EXPORT(rt_free);
# O7 |' \. |* j1 K0 Q

合并空闲块plug_holes

static void plug_holes(struct heap_mem *mem)
{
* y+ m. @& @$ i) z    struct heap_mem *nmem;
    struct heap_mem *pmem;
8 [4 f/ Q8 ~+ q" |4 ~3 `' p! i
    RT_ASSERT((rt_uint8_t *)mem >= heap_ptr);
! k: k) O+ l% l2 @# S6 }    RT_ASSERT((rt_uint8_t *)mem < (rt_uint8_t *)heap_end);
8 c5 Y$ B# g1 y4 f: E    RT_ASSERT(mem->used == 0);
8 L3 s0 U/ v- U4 x
' p- v5 \  ^7 B7 t# t    /* 前向整理 */
: a7 g) U0 y& P& k4 |, G2 B* O4 w& Y) s    nmem = (struct heap_mem *)&heap_ptr[mem->next];
$ p4 A' u! W2 q5 f& u    if (mem != nmem &&
        nmem->used == 0 &&
# }2 I* k8 s8 r        (rt_uint8_t *)nmem != (rt_uint8_t *)heap_end)
' C5 z$ g1 A6 R4 n2 z8 J4 t) W. ~    {
) A  K+ `; _0 }4 b& s& E        /*如果mem->next是空闲，且非尾节点，则合并*/
& v1 l8 J- k. m+ R5 \. h        if (lfree == nmem)
2 E$ a8 }3 a" ?3 E5 @2 b. {" e        {
            lfree = mem;
2 n1 ]% t- u' \. q! J" s( {2 r! X        }
        mem->next = nmem->next;
        ((struct heap_mem *)&heap_ptr[nmem->next])->prev = (rt_uint8_t *)mem - heap_ptr;
    }
0 b  Y, O, U; Y: u
    /* 后向整理 */
4 l/ p& `; ^) _2 P  b3 o) ]    pmem = (struct heap_mem *)&heap_ptr[mem->prev];
    if (pmem != mem && pmem->used == 0)
    {
* H; ~6 z1 K  g9 q4 S' L% [% j        /* 如mem->prev空闲,将mem与mem->prev合并 */
        if (lfree == mem)
5 J7 u. c! q* _        {
            lfree = pmem;
; Y- A9 l4 m6 t7 e" q+ b' t        }
        pmem->next = mem->next;
1 a2 ~9 k) q; P* w        ((struct heap_mem *)&heap_ptr[mem->next])->prev = (rt_uint8_t *)pmem - heap_ptr;
7 m7 \0 X( M, N3 P' [) C6 V% N    }
8 z$ N6 v; `' \& r; w}
" E6 }% J0 Z3 z( E  Z4 C9 s. K% B0 [

动态内存的释放相对比较简单，其思路主要是判断传入地址是否在堆区，如是堆内存，则判断其块信息是否合法。如果合法，则将使用标志清除。同时如果临近块如果是空闲态，则利用plug_holes将空闲块进行合并，合并成一个大的空闲块。

内存泄漏

使用free释放内存失败会导致不可重用内存的累积，程序不再使用这些内存。这将浪费内存资源，并可能在耗尽这些资源时导致分配失败。

怎么使用堆堆区的配置

对于STM32而言,位于board.h

/ * 配置堆区大小，可根据实际使用进行修改 */
#define HEAP_BEGIN   STM32_SRAM1_START
( ^. C) o6 V+ v7 a) ^1 p2 Q#define HEAP_END     STM32_SRAM1_END

3 d7 G3 G* x: ^& d7 ?5 K, Q/* 用于板级初始化堆区 */
void rt_system_heap_init(void *begin_addr, void *end_addr)
堆的使用接口用于动态申请内存
5 k1 v) W+ E7 U; uvoid *rt_malloc(rt_size_t size)
0 b+ O2 |- N5 x, g8 u3 L7 f3 |9 J/*追加申请内存，此函数将更改先前分配的内存块。*/
; H: P7 `+ u0 A4 }& h0 W; m1 E# i9 zvoid *rt_realloc(void *rmem, rt_size_t newsize)
/* 申请的内存被初始化为0 */
/ H, S) s: V: _4 D# p* svoid *rt_calloc(rt_size_t count, rt_size_t size)
$ C8 i5 A7 C3 M' d+ e

内存分配不能保证成功，而是可能返回一个空指针。使用返回的值，而不检查分配是否成功，将调用未定义的行为。这通常会导致崩溃，但不能保证会发生崩溃，因此依赖于它也会导致问题。

对于申请的内存，使用前必须进行返回值判断，否则申请失败，且任继续使用。将会出现意想不到的错误！！

总结一下

通过对RT-Thread的小堆管理器实现的梳理，层层递进更深入理解以下一些要点：

• 为什么需要堆，为什么堆是C/C++运行时的基础之一。堆可实现动态内存管理的多样性，在牺牲一定开销情况下（申请/释放开销，以及内存开销),可以提供内存的利用率，在一定程度上解决内存不足的需求。
• 可以更深入的理解链表实用价值，理解静态实现方法的一些技巧。
• 通过更深入的理解堆的实现，可以更好的使用堆。
• 理解堆管理器究竟在哪里实现的，C/C++标准库，以及操作系统内核都可能实现堆管理器。
• RT-Thread的小堆实现是一个比较简单和比较好的学习堆管理的例子，事实上堆的实现还有更复杂的场景，比如基于SLAB堆管理器实现，以及IAR中库的堆实现还需要使用树这个数据结构。
  0 F3 b6 Z  [$ b) b. P

堆使用常见错误

• 使用前没有检查分配失败：内存分配不能保证成功，而是可能返回一个空指针。使用返回的值，而不检查分配是否成功，将调用未定义的行为。这通常会导致崩溃，但不能保证会发生崩溃，因此依赖于它也会导致问题。
• 内存泄露：使用free释放内存失败会导致不可重用内存的累积，程序不再使用这些内存。这将浪费内存资源，并可能在耗尽这些资源时导致分配失败。逻辑错误：所有的分配必须遵循相同的模式:使用malloc分配，使用free存储数据，重新分配。如果不能坚持这种模式，例如在调用free(悬空指针)之后或在调用malloc(野生指针)之前使用内存、调用free两次(“double free”)等，通常会导致分段错误并导致程序崩溃。这些错误可能是暂时的，而且很难调试
  8 b8 H' Q" I9 b, A0 I; f6 `- G6 G

( P# H' U8 g5 {( N, {

谢谢分享