多进程循环socket问题

unix_neu

我编写了一个压力测试模块，实现是创建多个子进程，每个子进程循环发送多次交易信息，现在我参数定位10个子进程，每个循环发送10次，结果服务 器却未能收到100条记录。发送到一定数量后，就停止发送。实在不明白为什么，希望各位大虾给予解答！！在线等待!!
下面是源码：

1. int main(int argc, char *argv[])
   
2. {
   
3.   int                 nRet,i=0,j=0,itime=0;
   
4.         char                saSleep[20];
   
5.         char        sPwd[7];
   
6.         struct sockaddr_in   Sin;
   
7.         int   socket_id, Flag, Error, RetryTimeSap = 2, nRetryFlag = 0;
   
8.         unsigned Port = 32005;
   
9.         char Ip_addr[] = "11.1.160.131";        
   
10.         char sCfgName[30];
    
11.         char sDataName[30];
    
12.         char sMsgGmInq[1024];
    
13.         char sMsgAtmInq[1024];
    
14.         char sMsgGmCwd[1024];
    
15.         char sMsgAtmCwd[1024];
    
16.         char sMsgXfr[1024];
    
17.         char sMsgDps[1024];        
    
18.         char sMsgDcl[1024];
    
19.         char sMsgATMCwc[1024];
    
20.         char sMsgGMCwc[1024];
    
21.         char sHostSsn[9];
    
22.         char sOrigSsn[9];
    
23.         char sSendName[10];
    
24.         struct   sigaction sa;
    
25.         pid_t pid;
    
26.         //char filename[10];
    
27.         int lssn, iNum = 0;
    
28.         char c;
    
29.         char *p;
    
30.         int         k;
    
31.         int                m, sTIMES;
    
32.         char        sNetMsgBuf[BUF_SIZE];
    
33.         char        rspCode[3];
    
34.         char sDataBuf[4000];
    
35.         int  times;  //每个子进程循环发送迭代
    
36.         int totle;
    
37.         int totle_w;
    
38.         int totle_r, nums;        
    
39.         GetProfileString("SSN", "HOSTSSN", sHostSsn, "Ssn.cfg");
    
40.         nums = atoi(argv[1]);
    
41.         sTIMES = atoi(argv[2]);
    
42.         
    
43.         
    
44.         sa.sa_handler=SIG_IGN;
    
45.   sigaction(SIGPIPE,&sa,0);        
    
46.         memset(&Sin, 0, sizeof(Sin));
    
47.         memset(sCfgName,0,sizeof(sCfgName));
    
48. 
    
49.         Sin.sin_port = htons(Port);
    
50.         Sin.sin_family = AF_INET;
    
51.         Sin.sin_addr.s_addr = inet_addr(Ip_addr);
    
52.         strcpy(sSendName,"[1021]");        
    
53.         
    
54.         
    
55.         printf("Connect to %s at port %d!\n", Ip_addr, Port);
    
56.         sHostSsn[8] = 0;
    
57.         //printf("Begin sHostSsn=%s\n",sHostSsn);
    
58.         k=0;
    
59.         strcpy(sSendName,"[1211]");
    
60.         int nRc = Read8583Cfg(strcpy(sCfgName,FILE_CFG));
    
61.         if( nRc < 0 )
    
62.         {
    
63.                         printf("读取8583配置文件[%s]出错。\n",sCfgName);
    
64.                         return;
    
65.         }
    
66.         //printf("8583配置文件[%s]。\n",sCfgName);
    
67.                 /* 读测试数据 */
    
68.         for(;i<nums;i++)
    
69.         {
    
70.                 if((pid=fork())==0)
    
71.                 {
    
72.                 m=0;
    
73.                 printf("成功创建第%d个进程\n",i+1);                                                                                                
    
74.         totle_w=0;
    
75.         totle_r=0;
    
76.         memset(terminal_code, 0, sizeof(terminal_code));
    
77.         sprintf(terminal_code, "%08d", i+1);
    
78.         for(times=0;times<sTIMES;times++)
    
79.         {
    
80.                 while(1)
    
81.                 {
    
82.                         while ((socket_id = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
83.                         {
    
84.                                 printf("[%s][%d];socket Error!\n", __FILE__, __LINE__);
    
85.                                 if (nRetryFlag++ == 5)
    
86.                                 {
    
87.                                         if ( RetryTimeSap<100) RetryTimeSap += 2;
    
88.                                        
    
89.                                         nRetryFlag = 0;
    
90.                                 }
    
91.                                 sleep(RetryTimeSap);
    
92.                         }
    
93.                         
    
94.                         Setsokopt(socket_id);
    
95.                         if (connect(socket_id, (struct sockaddr *)&Sin, sizeof(Sin)) < 0)
    
96.                         {
    
97.                                 printf("[%s][%d];socket Error!\n", __FILE__, __LINE__);
    
98.                                 if (nRetryFlag++ == 5)
    
99.                                 close(socket_id);
    
100.                                 if (errno == ECONNREFUSED)
     
101.                                 {
     
102.                                         printf("\nCannot connect port %d:", Port);
     
103.                                         perror("");
     
104.                                         sleep(30);
     
105.                                         continue;
     
106.                                 }
     
107.                                 printf("Connect %s port %d error!\n",
     
108.                                                   Ip_addr, Port);
     
109.             
     
110.                         }
     
111.                         break;
     
112.                 }                                       
     
113.                 printf("第%d个进程第%d次成功连接\n",i+1,times+1);        
     
114.                 memset(sDataName,0,sizeof(sDataName));
     
115.                 //sprintf(sDataName,"file/test0.cfg");
     
116.                 sprintf(sDataName,"file/test%d.cfg",i);
     
117.                 if (ReadPETestData(sDataName,sSendName,times) != 0)
     
118.                 {
     
119.                                 printf("[%s][%d];socket Error!\n", __FILE__, __LINE__);
     
120.                                 if (nRetryFlag++ == 5)
     
121.                                 return;
     
122.                 }
     
123.                 /* 读测试数据 over*/
     
124. 
     
125.                 memset(MsgOut,0x00,sizeof(MsgOut));
     
126.                 nMsgLen = getSendData(MsgOut);                        
     
127.                 int ia = 0;
     
128.                 /*
     
129.                 while(ia != nMsgLen)
     
130.                 {
     
131.                         printf("%c",*(MsgOut+(ia++)) );               
     
132.                 }
     
133.                 */
     
134.                
     
135.                                 
     
136.                         nRetVal = WriteSocket( socket_id, MsgOut, nMsgLen);
     
137.                         if (nRetVal <=0)
     
138.                         {
     
139.                                 printf("Write socket call!\n");
     
140.                                 close(socket_id);
     
141.                                 /* return; */
     
142.                         }
     
143.                         printf("第%d个进程第%d次发送成功\n",i+1,times+1);
     
144.                         alarm(20);
     
145.                         memset(sNetMsgBuf, 0, sizeof(sNetMsgBuf));
     
146.                         nMsgLen=ReadSocket(socket_id,sNetMsgBuf,637);
     
147.                         if (nMsgLen <=0)
     
148.                         {
     
149.                                 alarm(0);
     
150.                                 if (nMsgLen == E_SBREAK)
     
151.                                 {
     
152.                                 printf("[%s][%d];socket Error!\n", __FILE__, __LINE__);
     
153.                                         printf("errno:[%d]\n",errno);
     
154.                                         printf("read socket call!\n");
     
155.                                         close(socket_id);
     
156.                                          exit(1);
     
157.                                 }
     
158.                                    else
     
159.                                    {
     
160.                                    printf("errno:[%d]\n",errno);
     
161.                                          return ;
     
162.                                 }
     
163.                         }
     
164.                         else
     
165.                         {
     
166.                         }
     
167.                         printf("第%d进程第%d次读取成功\n",i+1,times+1);
     
168.                         alarm(0);
     
169.                         /*解包，取出39域并打印*/
     
170.                         memset(rspCode,0,3);
     
171.                         Unpack8583(&sNetMsgBuf[11],128,rspCode);
     
172.                         if(memcmp("00",rspCode,2)==0)
     
173.                         {
     
174.                                 totle_r++;
     
175.                         }
     
176.                         else
     
177.                         {
     
178.                                 totle_w++;
     
179.                         }
     
180.                 close(socket_id);
     
181.           }
     
182.                   printf("第%d个进程执行到这里了\n",i+1);
     
183.                
     
184.                         printf("\n终端号0000000%d  一共[%d]笔，成功了[%d],失败[%d]\n",i+1,times,totle_r,totle_w);
     
185.                         
     
186.                 //close(socket_id);
     
187.                 exit(0);
     
188.           }
     
189.           if(pid<0)
     
190.                   {
     
191.                           printf("第%d次创建进程失败\n",i);
     
192.                   }
     
193.                   else{
     
194.                                 //printf("[%s][%d];socket Error!\n", __FILE__, __LINE__);
     
195.                           }
     
196.                 }
     
197.         }
     

复制代码

yu835

你看到创建的进程是有十次吗？SOCKET的while(1)里面有没有错误打印呢？一步步跟踪看是发送的时候没有循环发10次，还是发了但接收次数不够。

unix_neu

回复 2# yu835


    进程创建了10个 这个没问题。问题是  该模型是一发一收，循环某个read时停住了，造成了后面write不执行。我不清楚造成read时跳出函数的原因是什么？