c语言malloc不初始化，为什么没有占用系统空闲内存

一、目的

功能：实现嵌入式设备在检查系统内存不够的时，嵌入式系统能打印出日志

二、实现过程

详细检查系统剩余空间的功能就不详细介绍了，这里主要介绍如何造出异常，供嵌入式进行测试

 1 #include                                                                                          
  2 #include                                                                                           
  3 #include                                                                                          
  4 #include                                                                                          
  5                                                                                                             
  6 int main(int argc, char *argv[])                                                                            
  7 {                                                                                                           
  8 |   char* fd = NULL;                                                                                        
  9 |   int size = 0;                                                                                           
 10                                                                                                             
 11 |   printf("%s\n", argv[1]);                                                                                
 12 |   size = atoi(argv[1]);                                                                                   
 13 |   fd = malloc(size * 1024 * 1024);                                                                        
 14 |   if (fd == NULL) {                                                                                       
 15 |   |   perror("err\n");                                                                                    
 16 |   |   return -1;                                                                                          
 17 |   }                                                                                                       
 18 |   memset(fd, 0, size * 1024 * 1024);    //没有这句话，代码运行不出错，但是系统内存不会占用                                                                  
 19 |                                                                                                           
 20 |   printf("[%d]MB\n", size);                                                                               
 21 |   while (1) {                                                                                             
 22 |   }                                                                                                       
 23                                                                                                             
 24 |   return 0;                                                                                               
 25 }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1、如果没有18行的代码

 18 |   memset(fd, 0, size * 1024 * 1024);    //没有这句话，代码运行不出错，但是系统内存不会占用      
1

查看系统运行前

└──╼ $free -m
              total        used        free      shared  buff/cache   available
Mem:           6948        3420         295         174        3232        3104
Swap:          6784           3        6781

1
2
3
4
5

运行后：

└──╼ $free -m
              total        used        free      shared  buff/cache   available
Mem:           6948        3420         295         174        3232        3104
Swap:          6784           3        6781

1
2
3
4
5

2、增加上18行的代码

查看系统运行前

└──╼ $free -m
              total        used        free      shared  buff/cache   available
Mem:           6948        3420         295         174        3232        3104
Swap:          6784           3        6781

1
2
3
4
5

查看运行后

└──╼ $free -m                                                                                                   
              total        used        free      shared  buff/cache   available
Mem:           6948        3519         198         172        3230        3006
Swap:          6784           3        6781
1
2
3
4

明显空闲内存free的空间少了100MB

原因

自己在memset之后，使用free命令查看内存才会发生变化，那么猜想只有在申请的内存在发生变化的时候系统才会认为，此时的空闲内存已经被申请占用，为了验证自己的想法，在申请100M的内存，后，只进行初始化50M的内存，发现结果如自己想象的那样。有条件的小伙伴可以留言讨论。

这也就是说如果在没有初始化的情况的，应该是可以无限进行malloc的，但实际并非如此，我们可以来做个实验

#include 
#include 
#include 
#include 
#include 
#include 



int info(void)
{
 struct sysinfo info;
 int iRetVal = -1;/*用于获取函数的返回值，默认为-1*/
 iRetVal = sysinfo(&info);
 printf("return val         : %d\n",iRetVal);//打印函数返回值，成功为0，失败为-1  
 printf("uptime          : %ld\n",info.uptime);//打印从设备开启到现在的时间，单位为秒    
 printf("1 min load average : %lu\n",info.loads[0]);    
 printf("5 min load average : %lu\n",info.loads[1]);    
 printf("15 min load average: %lu\n",info.loads[2]);//平均负载    
 printf("totalram           : %lu\n",info.totalram);//总可用内存大小  
 printf("freeram            : %lu\n",info.freeram); //剩余内存   
 printf("freeram:%lu MB\n", info.freeram / 1024 / 1024);
 printf("procs              : %u\n",info.procs);    //进程数
 return 0;
}

int main(int argc, char *argv[])
{
	char* fd = NULL;
	int size = 0;
	int i =0;

	printf("%s\n", argv[1]);
	size = atoi(argv[1]);
	for (i=0; i<100000000; i++) {
		fd = malloc(size * 1024 * 1024);
//		memset(fd, 0, size * 1024 * 1024);
		if (fd == NULL) {
			perror("err\n");
			system("free -m");
			info();
			return -1;
		}
//		sleep(1);
//		info();
	}
//	memset(fd, 0, size * 1024 * 1024);
	
	printf("[%d]MB\n", size);
	while (1) {
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

可以通过sysinfo（）系统函数获取其中空闲内存，结果如下

fd:(nil)
err
: Cannot allocate memory
return val         : 0
uptime          : 3410
1 min load average : 277440
5 min load average : 246464
15 min load average: 204960
totalram           : 7285850112
freeram            : 746704896
freeram:712 MB
procs              : 1792
1
2
3
4
5
6
7
8
9
10
11
12

即使在内存耗尽的情况下，获取到空闲的内存仍然为712M，没有发生变化，这就是说在没有memset的情况下，会发生错误，因此这个一个bug问题。。。。。。。

在知乎上找到一个比较合理的解释