线程创建子线程，线程退出时，释放了内存，但是TOP中只看到有一般的内存被释放了

一只嗡嗡的苍蝇

gcc和操作系统均有可能有内存池。

korpus

回复 10# gaojl0728


    就是最奇怪的就是，如果我把LOG_DEBUG("Thread Will Quit");  这行注释掉，top命令显示就是正常的。

korpus

回复 9# folklore


    你好，谢谢的你的关注哈。

进程结束，内存是会被回收的，现在是在线程里面。

korpus

回复 11# 一只嗡嗡的苍蝇


    你好，谢谢你的关注。
能不能确认这个内存池呢

folklore

上 Valgrind 吧。

korpus

我把代码整理出来了一份可以独立编译  

比较奇怪的是如果注释掉函数 trans_SingleThread  LOG_DEBUG("Thread Will Quit [%ld]", pthread_self());，释放回正常，如果没注释释放就不正常了

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <errno.h>
   
6. #include <stdarg.h>
   
7. #include <sys/timeb.h>
   
8. #include <sys/stat.h>
   
9. #include <pthread.h>
   
10. 
    
11. typedef enum
    
12. {
    
13.     LOG_LEVEL_ERROR, // only print ERROR log
    
14.     LOG_LEVEL_WARN,  // print ERROR and WARN log
    
15.     LOG_LEVEL_INFO,  // print ERROR, WARN and INFO log
    
16.     LOG_LEVEL_DEBUG,  // print ERROR, WARN, INFO AND DEBUG log
    
17.     LOG_LEVEL_ALL    // print all log, and print full debug log and other informations
    
18. }LOG_LEVEL;
    
19. 
    
20. static char g_szLogHead[200];
    
21. static long g_iSetLogLevel = 3;
    
22. static long g_lSetLogSize = 0;
    
23. static int g_iLogLevel;
    
24. static char g_szLogFile[256]="./test.log";
    
25. pthread_mutex_t g_WriteLog = PTHREAD_MUTEX_INITIALIZER;
    
26. static char g_szLogPath[128]=".";
    
27. static char g_szLogName[128]="test.log";
    
28. 
    
29. #define LOG_ERROR       Log_SysInfo(LOG_LEVEL_ERROR,__FILE__,__LINE__),Log_Msg
    
30. #define LOG_WARN        Log_SysInfo(LOG_LEVEL_WARN,__FILE__,__LINE__),Log_Msg
    
31. #define LOG_INFO        Log_SysInfo(LOG_LEVEL_INFO,__FILE__,__LINE__),Log_Msg
    
32. #define LOG_DEBUG       Log_SysInfo(LOG_LEVEL_DEBUG,__FILE__,__LINE__),Log_Msg
    
33. #define RT_SUCCESS      0
    
34. #define RT_FAILURE      -1
    
35. 
    
36. void Log_Check();
    
37. 
    
38. long timel_GetCurrentTime()
    
39. {
    
40.     char szTime[7];
    
41.     long lCurTime;
    
42.     struct tm *ptime;
    
43.     time_t times;
    
44.     time(&times);
    
45.     ptime = localtime(&times);
    
46.     memset(szTime, 0, sizeof(szTime));
    
47.     sprintf(szTime, "%02d%02d%02d", ptime->tm_hour, ptime->tm_min, ptime->tm_sec);
    
48.     lCurTime = atol(szTime);
    
49.     return lCurTime;
    
50. }
    
51. 
    
52. long timel_GetCurrentDate()
    
53. {
    
54.     char szDate[9];
    
55.     long lDate;
    
56.     struct tm *ptm;
    
57.     time_t times;
    
58.     time(&times);
    
59.     ptm = localtime(&times);
    
60.     memset(szDate, 0, sizeof(szDate));
    
61.     sprintf(szDate, "%d%02d%02d", ptm->tm_year+1900, ptm->tm_mon + 1, ptm->tm_mday);
    
62.     lDate = atol(szDate);
    
63.     return lDate;
    
64. }
    
65. 
    
66. void timev_GetLogTime(char *out_pLogTime)
    
67. {
    
68.     struct timeb ptm;
    
69.     struct tm *ptmb;
    
70. 
    
71.     ftime(&ptm);
    
72.     ptmb = localtime(&ptm.time);
    
73.     sprintf(out_pLogTime, "%02d-%02d %02d:%02d:%02d.%03d", ptmb->tm_mon+1, ptmb->tm_mday,
    
74.                        ptmb->tm_hour, ptmb->tm_min, ptmb->tm_sec, ptm.millitm);
    
75.     return ;
    
76. }
    
77. 
    
78. void Log_SysInfo(const int iLogLevel, const char *pszFileName, const int iNum)
    
79. {
    
80.     int i = 0;
    
81.     char szLogTime[30];
    
82. 
    
83.     pthread_mutex_lock(&g_WriteLog);
    
84. 
    
85.     memset(szLogTime, 0, sizeof(szLogTime));
    
86.     memset(g_szLogHead, 0, sizeof(g_szLogHead));
    
87. 
    
88.     g_iLogLevel = iLogLevel;
    
89. 
    
90.     if(g_iSetLogLevel < g_iLogLevel)
    
91.     {
    
92.         return;
    
93.     }
    
94. 
    
95.     Log_Check();
    
96. 
    
97.     timev_GetLogTime(szLogTime);
    
98.     snprintf(g_szLogHead, sizeof(g_szLogHead), "%s %s L=%d T=%ld E=%d ", szLogTime, pszFileName,
    
99.                  iNum, pthread_self(), errno);
    
100. 
     
101.     switch(iLogLevel)
     
102.     {
     
103.         case LOG_LEVEL_ERROR:
     
104.              sprintf(g_szLogHead + strlen(g_szLogHead), "%s", "[ERROR] ");
     
105.              break;
     
106.         case LOG_LEVEL_WARN:
     
107.              sprintf(g_szLogHead + strlen(g_szLogHead), "%s", "[WARN] ");
     
108.              break;
     
109.         case LOG_LEVEL_DEBUG:
     
110.              sprintf(g_szLogHead + strlen(g_szLogHead), "%s", "[DEBUG] ");
     
111.              break;
     
112.         case LOG_LEVEL_INFO:
     
113.              sprintf(g_szLogHead + strlen(g_szLogHead), "%s", "[INFO] ");
     
114.              break;
     
115.         case LOG_LEVEL_ALL:
     
116.              sprintf(g_szLogHead + strlen(g_szLogHead), "%s", "[ALL] ");
     
117.              break;
     
118.         default:
     
119.              break;
     
120.     }
     
121. }
     
122. 
     
123. void Log_Check()
     
124. {
     
125.     struct stat st;
     
126.     int iRet;
     
127.     char szLogDate[9];
     
128. 
     
129.     memset(szLogDate, 0, sizeof(szLogDate));
     
130.     memcpy(szLogDate, g_szLogFile + strlen(g_szLogPath) + 1, 8);
     
131. 
     
132.     if(atol(szLogDate) == timel_GetCurrentDate())
     
133.     {
     
134.         if(g_lSetLogSize > 0)
     
135.         {
     
136.             stat(g_szLogFile, &st);
     
137.             if(st.st_size / 1024 / 1024 >= g_lSetLogSize)
     
138.             {
     
139.                 snprintf(g_szLogFile, sizeof(g_szLogFile), "%s/%ld/%s.%ld%s%06d", g_szLogPath,
     
140.                         timel_GetCurrentDate(), g_szLogName,
     
141.                         timel_GetCurrentDate(), "_", timel_GetCurrentTime());
     
142.             }
     
143.             
     
144.         }
     
145.     }
     
146.     else
     
147.     {  
     
148.         if(g_lSetLogSize > 0)
     
149.         {
     
150.             snprintf(g_szLogFile, sizeof(g_szLogFile), "%s/%ld/%s.%ld%s%06d", g_szLogPath,
     
151.                     timel_GetCurrentDate(), g_szLogName,
     
152.                     timel_GetCurrentDate(), "_", timel_GetCurrentTime());
     
153. 
     
154.         }
     
155.         else
     
156.         {
     
157.             snprintf(g_szLogFile, sizeof(g_szLogFile), "%s/%ld/%s.%ld", g_szLogPath,
     
158.                         timel_GetCurrentDate(), g_szLogName,
     
159.                         timel_GetCurrentDate());
     
160.         }
     
161.     }
     
162. }
     
163. 
     
164. void Log_Msg(const char *format, ...)
     
165. {
     
166.     FILE *fp;
     
167.     va_list args;
     
168.     int  olderrno;
     
169.     int i;
     
170. 
     
171.     if(g_iSetLogLevel < g_iLogLevel)
     
172.     {
     
173.         pthread_mutex_unlock(&g_WriteLog);
     
174.         return;
     
175.     }
     
176.     olderrno = errno;     
     
177. 
     
178.     if(NULL != (fp = fopen(g_szLogFile, "a+")))
     
179.     {
     
180.         fprintf(fp, "%s", g_szLogHead);
     
181.         va_start(args, format);
     
182.         vfprintf(fp, format, args);
     
183.         va_end(args);
     
184.         fprintf(fp, "%s", "\n");
     
185.         fclose(fp);
     
186.     }
     
187.     else
     
188.     {
     
189.         printf("fopen error, errno=%d, file=%s\n", errno, g_szLogFile);
     
190.         perror("fopen");
     
191.     }
     
192.     errno = olderrno;
     
193. 
     
194.     pthread_mutex_unlock(&g_WriteLog);
     
195. }
     
196. 
     
197. void *ufs_MallocMemory(const long lSize)
     
198. {
     
199.     void *pAddr = NULL;
     
200.     if(lSize <= 0)
     
201.     {
     
202.         LOG_ERROR("malloc memory size less than zero");
     
203.         return NULL;
     
204.     }
     
205. 
     
206.     pAddr = malloc(lSize);
     
207.     if(NULL == pAddr)
     
208.     {
     
209.         LOG_ERROR("malloc memory size error!, malloc size(%d)", lSize);
     
210.         return NULL;
     
211.     }
     
212. 
     
213.     memset(pAddr, 0, lSize);
     
214. 
     
215.     return pAddr;
     
216. }
     
217. 
     
218. void ufs_vFreeNormalMemory(void **pAddr)
     
219. {
     
220.     if(NULL == *pAddr)
     
221.         return;
     
222.     else
     
223.         free(*pAddr);
     
224.     *pAddr = NULL;
     
225. }
     
226. 
     
227. void *trans_SingleThread(void *pData)
     
228. {
     
229.     int iRet;
     
230.     void *pReadMemory = NULL;
     
231.     void *pWriteMemory = NULL;
     
232. 
     
233.     pWriteMemory = ufs_MallocMemory(20971520);
     
234.     if(NULL == pWriteMemory)
     
235.     {
     
236.         LOG_ERROR("Malloc Memory Failure!");
     
237.         ufs_vFreeNormalMemory(&pReadMemory);
     
238.         iRet = RT_FAILURE;
     
239.         pthread_exit((void *)&iRet);
     
240.     }
     
241. 
     
242.     pReadMemory = ufs_MallocMemory(20971520);
     
243.     if(NULL == pReadMemory)
     
244.     {
     
245.         LOG_ERROR("Malloc Memory Failure!");
     
246.         iRet = RT_FAILURE;
     
247.         pthread_exit((void *)&iRet);
     
248.     }
     
249. 
     
250.     sleep(5);
     
251. 
     
252.     LOG_DEBUG("Thread Will Quit [%ld]", pthread_self());
     
253. 
     
254.     ufs_vFreeNormalMemory(&pReadMemory);
     
255.     ufs_vFreeNormalMemory(&pWriteMemory);
     
256. 
     
257. 
     
258.     pthread_exit((void *)&iRet);
     
259. }
     
260. 
     
261. void *pFunc(void *pData)
     
262. {
     
263.     int *iTime = (int *)pData;
     
264.     long lThreadID[10];
     
265.     int i;
     
266. 
     
267.     *iTime = 5;
     
268.     while(1)
     
269.     {
     
270.         for(i = 0; i < *iTime; i ++)
     
271.         {
     
272.             if(pthread_create(&lThreadID[i], NULL, trans_SingleThread, NULL) < 0)
     
273.             {
     
274.                 printf("create error\n");
     
275.                 exit(0);
     
276.             }
     
277.       
     
278. 
     
279.             LOG_DEBUG("Success Create Thread [%ld]", lThreadID[i]);
     
280.         }
     
281. 
     
282.         for(i = 0; i < *iTime; i ++)
     
283.         {
     
284.             pthread_join(lThreadID[i], NULL);
     
285.             LOG_DEBUG("Thread [%ld] Quit Success!", lThreadID[i]);
     
286.         }
     
287. 
     
288.         sleep(*iTime * 5);
     
289.     }
     
290. }
     
291. 
     
292. int main(int argc, char *argv[])
     
293. {
     
294.     long lThreadID[10];
     
295.     int i;
     
296.     int iRet;
     
297.     int iThreadNums;
     
298. 
     
299.     iThreadNums = atoi(argv[1]);
     
300. 
     
301.     if(iThreadNums > 10 || argc != 2)
     
302.     {
     
303.         printf("less than 10, or input 2 args!\n");
     
304.         exit(0);
     
305.     }
     
306. 
     
307.     sleep(5);
     
308. 
     
309.     for(i = 0; i < iThreadNums; i ++)
     
310.     {
     
311.         iRet = pthread_create(&lThreadID[i], NULL, pFunc, &iThreadNums);
     
312.         if(iRet < 0)
     
313.         {
     
314.             printf("error ,exit!\n");
     
315.             exit(0);
     
316.         }
     
317. 
     
318.         LOG_DEBUG("Create Initinal Thread [%ld]", lThreadID[i]);
     
319.     }
     
320. 
     
321.     while(1)
     
322.     {
     
323.         sleep(2);
     
324.     }
     
325. }
     

复制代码

makefile如下

1. all:TestMemory
   
2. 
   
3. TestMemory:thread.o
   
4.         cc -o TestMemory thread.o -lpthread
   
5.         rm -f thread.o
   
6. thread.c:thread.o
   
7.         cc -c thread.c

复制代码

gaojl0728

回复 16# korpus


    抓了个strace看了下， LOG_DEBUG存在的时候Glibc没有释放那20M内存给内核。 要想知道详细的原因只能看glibc了， 可惜glibc代码的可读性太差， 不好看啊

korpus

回复 17# gaojl0728


    你好，你用strace怎么看的呢？

    如果glibc没有返回给系统，正常吗？

gaojl0728

回复 18# korpus


   
strace -f -p "pid of your program"能看到程序调用的系统调用， 对于大于128K的内存分配， glibc会调用mmap/munmap/madvise分配释放内存，

你的程序分别分配了两块20M的内存，然后分别释放掉：
1. 没有LOG_DEBUG的时候,  一块20M内存是通过munmap释放掉的，另一块20M是madvise释放掉的。
2. 有LOG_DEBUG的时候， 一块20M内存是通过munmap释放掉的, 另一块没有释放被glibc 回收缓存了。

通常内存池会回收并缓存释放的内存而不归还给内核，这是正常的行为，不是内存泄露。
要想知道原因只能看glibc的源代码， 可能pthread的相关函数做了某些特殊处理。

korpus

回复 19# gaojl0728


    谢谢你哈。我看看。