求救：子线程不断吃内存

sblig

申明一个全局的字符串二维数组
static char p_udp[15000][500];

A 子线程
   进行循环给p_udp这个二维字符串赋值

B 子线程
   进行读取p_udp这个二维字符串数组

top查看的时候，进程是在不断增长

下面是代码

1. 
   
2. //全局控制变量
   
3. static char p_udp[15000][500];
   
4. #define MAXPACKET = 15000
   
5. static int  icount = 0;//包序
   
6. static int  icountMAX = 0;//包序已经达到最大值保存
   
7. static int  icountDB = 0;//当前入库包序
   
8. static int  icountDBCur = 0;//当前提交入库
   

复制代码

A子线程代码如下

1. 
   
2. void handle_udp (const u_char* packet)
   
3. {
   
4.         ......抓UDP包
   
5.         if (size_buf)
   
6.         {
   
7.                 buf = (char *) (packet + size_ip + size_udp + offset);
   
8.         
   
9.                 if(icount >= MAXPACKET)
   
10.                 {
    
11.                         icount = 0;
    
12.                         icountMAX = MAXPACKET;
    
13.                 }
    
14.                 if(size_buf>0)
    
15.                 {
    
16.                         strncpy(p_udp[icount],buf,size_buf);//这个地方是不断增长的原因
    
17.                         icount++;
    
18.                 }
    
19.         }
    
20. }
    

复制代码

B子线程代码如下

1. 
   
2. void run_insert(void)
   
3. {
   
4. 
   
5.         int irows;
   
6.         while(1)
   
7.         {
   
8.                 usleep(30000);
   
9.                 irows = 0;
   
10.                 icountDBCur = icount;
    
11.                 if(icountMAX >= MAXPACKET)
    
12.                 {
    
13.                         icountDBCur = icountMAX;
    
14.                 }
    
15.                 for(;icountDB < icountDBCur ;icountDB++)
    
16.                 {
    
17.                         strcpy(strtemp,p_udp[icountDB]);
    
18.                         insertDB(strtemp);//入库
    
19.                         if(iexit)
    
20.                         {
    
21.                                 EXEC SQL COMMIT;
    
22.                                 return;
    
23.                         }
    
24.                         if(icountDB+1 == icountDBCur)
    
25.                         {
    
26.                                 EXEC SQL COMMIT;
    
27.                                 sprintf(logs,"=======【%d】===【next data is empty】=========\n",icountDB);
    
28.                                 debugLog(logs);
    
29.                                 icountDB++;
    
30.                                 if(icountDB >= MAXPACKET)
    
31.                                 {
    
32.                                         icountDB = 0;
    
33.                                         icountMAX = 0;
    
34.                                         icountDBCur = 0;
    
35.                                 }
    
36.                                 break;
    
37.                         }
    
38.                         if(irows > 1000)
    
39.                         {
    
40.                                 EXEC SQL COMMIT;
    
41.                                 sprintf(logs,"=======【%d】===【accumulate data more 1000】=========\n",irows);
    
42.                                 debugLog(logs);
    
43.                                 icountDB++;
    
44.                                 break;
    
45.                         }
    
46.                         irows++;
    
47.                 }
    
48.         }
    
49. }

复制代码

samlumengjun

buf = (char *) (packet + size_ip + size_udp + offset);
buf之后free了吗?

sblig

buf = (char *) (packet + size_ip + size_udp + offset);
buf之后free了吗?
samlumengjun 发表于 2010-11-22 18:18

     不是这个的原因  当我注释掉下面这个行，内存马上就不增长了
    strncpy(p_udp[icount],buf,size_buf);//这个地方是不断增长的原因

    线程共享全局变量是否有问题

jerryz920

没看到malloc哪来的泄露……查一下insertDB是否有泄漏。如果insertDB根据传入的字符串长度来申请内存，然后还不释放，倒是有可能发生你说的情况，因为注释掉以后很可能strtemp就是个0串，于是没有申请内存。

另一种可能是你看到的增长不是实际地内存泄露，只是被操作系统cache起来了。

sblig

没看到malloc哪来的泄露……查一下insertDB是否有泄漏。如果insertDB根据传入的字符串长度来申请内存，然后 ...
jerryz920 发表于 2010-11-22 19:05

    是这种情况，内存增长，我结束进程的时候又全部释放掉了，增长可以达到1.6G

jerryz920

回复 5# sblig


    valgrind一下呢

nizvoo

1，子线程不启动
2，子线程部分启动

排除错误

sblig

pcap_loop 不断抓包，内存就会不断增长。。

lsupper

看不出...汗...等待高手...

sblig

.等待高手.