亲宝软件园·资讯

展开

C内存管理

​ 编程学习网   ​ 人气:0

内容提要:

大家写C程序时,手工申请过内存吗?每次需要存储空间时都向操作系统申请吗?使用完申请到的内存后有把它还给操作系统吗?遇到过“段错误”吗?本文的主题和这一串问题有很大的关系。

1.malloc

手工申请内存使用malloc。先看一段例程。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char *say_hi();

int main(int argc, char *argv[])
{
   char *str = say_hi();
   printf("str = %s\n", str);
   free(str);
   return 0;
}

char *say_hi()
{
   char *ptr = (char *)malloc(100);
   char *str = "how are you?";
   strcpy(ptr, str);
  
   return ptr;
}

执行结果如下:

[root@localhost compiler-basic]# gcc -o t t.c -g -m32
[root@localhost compiler-basic]# ./t
str = how are you?

把修改成:

char *say_hi()
{
   char *ptr = (char *)malloc(100);
   char *str = "how are you?";
   strcpy(ptr, str);
  
   return str;
}

执行结果如下:

[root@localhost compiler-basic]# gcc -o t t.c -g -m32
[root@localhost compiler-basic]# ./t
str = how are you?
Segmentation fault (core dumped)

在第二版say_hi中,返回值是str,我们看到,打印出的数据是how are you?。然而,这只是偶尔正确。C语言的函数并不能总是正确返回非数字类型的局部变量的值。在程序变得复杂后,保不准某个时候这样的函数就不能返回预期数据。

Segmentation fault (core dumped),这又是怎么回事呢?str不是malloc申请到的内存空间,用free释放它导致错误。

2.内存泄露

用malloc申请了内存空间却不用free释放,会造成内存泄露。

在前面的第二版say_hi中,ptr指向的内存空间就被泄露了。在程序员看来,执行完say_hi后,ptr指向的内存就没有价值了;由于没有正确地释放它,操作系统认为它仍然在使用中,当其他进程申请内存时,不会把这片内存回收重新分配。

像这样的内存泄露越来越多,会一直多到耗尽所有的内存。但实际上,那些被泄露的内存是完全应该被回收再使用的。

内存泄露后,会成为操作系统和程序员都无法掌控的内存。

我们在手工申请内存、使用完毕之后,一定要释放内存。malloc和free犹如一对连体婴儿,总是一起使用。

3.内存池

前面的例子,在say_hi使用malloc,在main使用free。连体婴儿却只能出现在两个函数中,这很危险。一不留神,就会忘记释放内存。

每次申请内存都使用malloc,需要陷入内核,性能开销很大。

有朋友会说,我只是个小菜鸟,暂时还不需要考虑性能开销,只要我写的程序能跑就行。

哈哈,你并不是第一个这么想的人,我也是这样想的,所以我不厌其烦地、勤快地多次使用malloc。终于,在昨天,我遇到了非常烦人的段错误。

段错误发生在malloc中,导致错误的函数调用链不同,在测试数据中随便加几个字符后错误又消失。断点调试不管用,在前几十次执行malloc没有段错误,在后面几十次中的某一次执行malloc时才出现段错误。段错误出现在内核中。内核是不会有问题的,即使问题指向内核,那一定是向内核提供了错误的输入数据。

在束手无策快要绝望之前,我把原始的malloc换成了向内存池申请内存。先前发生的奇怪错误,再也没有出现了。

4.理论

内存池,是使用malloc申请的一段内存;进程需要内存空间时,从这段内存中拿一块去用;当这段内存被用完后,再使用malloc申请一段新内存;像这样重复这个过程。

很容易发现,内存池减少了使用malloc的次数;在进程结束前,程序员能方便地一次性释放这些内存。

5.代码数据结构

struct mblock{
   char *begin;
   char *avail;
   char *end;
};

typedef struct heap{
  struct mblock *last;
   struct mblock head;
} *Heap;

#define HEAP(hp) struct heap hp = { &hp.head }
Heap CurrentHeap;
struct heap ProgrameHeap;
int HeapAlloc(Heap hp, int size);
void *do_malloc(int size);

6.代码

char *HeapAlloc(Heap hp, int size){
   struct mblock *blk = NULL;
   blk = hp->last;
  
   while(size > blk->end - blk->avail){
       int m = 4096 + sizeof(struct mblock) + size;
       blk->next = malloc(m);
       blk = blk->next;
       if(blk == NULL){
           printf("内存耗尽\n");
           exit(-1);
        }
       blk->begin = blk->avail = (char *)(blk + 1);
       blk->end = (char *)blk + m;
       hp->last = blk;
    }
  
   blk->avail += size;
  
   return blk->avail - size;
}

void *do_malloc(int size){
  CurrentHeap = HEAP(ProgrameHeap);
   void *p = HeapAlloc(CurrentHeap, size);
   memset(p, 0, size);
  
   return 0;
}

要申请内存的时候,原来是使用malloc,现在,我们有了上面的这套内存管理机制后,就使用do_malloc来申请内存。

**解说
HEAP**
这个宏把heap的第一个成员last的值设置成第二个成员head的内存地址。

要熟悉这种{ &hp.head }初始化结构体的语法。

7.blk->begin

blk->begin = blk->avail = (char *)(blk + 1);

先看blk + 1。它表示,在blk的基础上,往后移动sizeof(struct mblock)个字节。指针的加减就是这么计算的。

blk指向一段m个字节的内存空间,这段内存空间的前sizeof(struct mblock)个字节存储一个mblock结构。怎么理解这个结构?它是这段内存空间的元数据。了解文件系统的实现机制的朋友会很容易理解这一点。

从元数据中,获取begin、avail、end。

如果把blk->begin做如下修改。

blk->begin = blk->avail = (char *)(blk);

怎么样?我们来推演一番。

blk->end最后一个问题,理解下面的代码。

blk->end = (char *)blk + m;

blk->end表示新申请的这片内存的末尾地址。

末尾地址等于初始地址加上这片内存的长度。看看上面的代码是不是这个意思。

(char

)blk + m就是这个意思。而(char

)(blk + m)就不是这个意思。

blk是这片内存的第一个字节,(char *)blk + m-1是这片内存的最后一个字节。

8.总结

每个内存池的开头都有一个mblock,存储这个内存池的元数据(begin、avail、end、next)。进程需要内存时,先向内存池申请。当前内存池容量不够时,再向系统申请一个内存池。把这个内存池连接到前一个内存池的元数据的next上。

一个内存池耗尽后,并非全部空间都被使用了。没有被利用的空间,在当前机制下,被浪费了。以后再找机会优化。

所有的内存池构成一个单链表。当进程完成它的功能后,在结束前,遍历这个单链表,从元数据中获取begin,然后调用free(begin)就能释放所有的内存。

加载全部内容

相关教程
猜你喜欢
用户评论