内存释放问题

airhello

写了一个小程序，不断地申请内存，每次申请1024字节，一直申请到1G，也就是申请1024*1024次。
申请完后，过一会，我就把这些内存全部释放了，但从ps aux或top来看，内存占用量还是1G多，一直不下降。

我知道，内存申请后，free时不一定真正释放。但这大的内存free后，还一直不降，很是不理解。

附上代码。只是为了测试内存而写，用信号来控制申请与释放。执行命令：./test size，其中size为分配给buf的大小。运行后，kill -55 pid来free内存。

1. #include <stdio.h>
   
2. #include <signal.h>
   
3. 
   
4. struct memnode
   
5. {
   
6.         struct memnode *next;
   
7.         unsigned char *buf;
   
8.         unsigned int buf_len;
   
9. };
   
10. 
    
11. unsigned char tag = 1;
    
12. 
    
13. void sig_55(void)
    
14. {
    
15.         if(tag)
    
16.                 tag = 0;
    
17.         else
    
18.                 tag = 1;
    
19. }
    
20. 
    
21. int main(int argc, char *argv[])
    
22. {
    
23.         struct memnode *head = NULL, *p = NULL;
    
24.         int size = 0;
    
25.         unsigned int malloc_num = 0;
    
26.         unsigned int free_num = 0;
    
27. 
    
28.         if(argc != 2){
    
29.                 printf("input error!\n");
    
30.                 exit(-1);
    
31.         }
    
32. 
    
33.         size = atoi(argv[1]);
    
34. 
    
35.         signal(55, &sig_55);
    
36. 
    
37.         printf("MemUnitSize: %d\n", size);
    
38. 
    
39.         while(1){
    
40.                 if(tag){
    
41.                         if(malloc_num > 1024*1024){
    
42.                                 sleep(1);
    
43.                                 continue;
    
44.                         }
    
45. 
    
46.                         p = (struct memnode *)malloc(sizeof(struct memnode));
    
47.                         if(NULL == p){
    
48.                                 exit(-1);
    
49.                         }
    
50. 
    
51.                         p->buf = (unsigned char *)malloc(size*sizeof(unsigned char));
    
52.                         if(NULL == p->buf){
    
53.                                 exit(-1);
    
54.                         }
    
55. 
    
56.                         p->next = head;
    
57.                         head = p;
    
58.                         malloc_num++;
    
59.                 }
    
60.                 else{
    
61.                         p = head;
    
62.                         if(p == NULL){
    
63.                                 sleep(1);
    
64.                                 continue;
    
65.                         }
    
66. 
    
67.                         while(p){
    
68.                                 head = p->next;
    
69.                                 free(p->buf);
    
70.                                 free(p);
    
71.                                 free_num++;
    
72.                                 p = head;
    
73.                         }
    
74.                         printf("malloc_num: %d, free_num: %d\n", malloc_num, free_num);
    
75.                 }
    
76.         }
    
77. 
    
78.         exit(0);
    
79. }
    

复制代码

rain_fish

代码？

greensnow

是这样的，你用mallinfo可以看到那部分内存被系统保留了。。

JCheung

你是不是有野指针了?
还有你的p????是从何而来的?

bluewaterray

看看这个，是否有帮助
http://hi.baidu.com/shengit/blog ... 1f3f1b6227983a.html

lengyuex

我认为你看top的时候内存会慢慢下降。

doofy

测试了下，现象如下：
1. 如果每次1k，malloc 1000000次，内存不能及时清理，且响应信号的时间比较长，大概有5-6s的样子；
2. 如果每次1M，malloc1000次，内存迅速就释放了

1000000个1k，内存成什么样子了....

airhello

回复 6# lengyuex

我上午10点开始跑，到现在14:50了，top一直显示内存占用1033m

airhello

回复 7# doofy

呵呵，本来也不会写这种测试代码。只是项目中的一个网络数据包处理程序在运行一段时间后，占用内存不断增长，就算停止网络流量后也降不了。
最后发现，这个程序malloc/free特别多，所以就写了一个这样的测试程序。

但linux的malloc/free无法处理这么大量的内存分配和释放吗??

airhello

回复 3# greensnow

呵呵，谢谢提醒。

用mallinfo查看了一下内存情况，结果发现，同样malloc 1G内存，
如果是每次malloc 1k，总共malloc 1024*1024次，发现malloc从操作系统获取内存的方式是sbrk()。
如果是每次malloc 1m，总共malloc 1024次，发现malloc从操作系统获取内存的方式是mmap。

网上的一些资料说，通过sbrk()申请的内存，在free之后，是不会还给操作系统的，而是加到total heap中。而mmap则可以。

问题好像又进了一步了。

但不明白的是，为什么sbrk()申请的内存，不能动态调整一下。