使用 epoll 问题。

benjiam

1. #include <pthread.h>
   
2. 
   
3. #include <sys/epoll.h>
   
4. 
   
5. #include <sys/types.h>
   
6. #include <sys/socket.h>
   
7. #include <arpa/inet.h>
   
8. #include <netdb.h>
   
9. #include <unistd.h>
   
10. #include <fcntl.h>
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include <string.h>
    
14. #include <errno.h>
    
15. 
    
16. #define maxevents 200
    
17. #define max_thread 6000
    
18. #define MAXLINE   1024
    
19. #define max_connect 5
    
20. 
    
21. void *work(void *arg);
    
22. void setnonblocking(int sock);
    
23. void do_use_fd(struct epoll_event   *events);
    
24. 
    
25. pthread_mutex_t lock_mutex = PTHREAD_MUTEX_INITIALIZER;
    
26. 
    
27. int lines   = 0;
    
28. int epollfd = 0;
    
29. 
    
30. int main(){
    
31. 
    
32.         pthread_t pid_t;
    
33.         struct epoll_event ev, events[maxevents]={0};
    
34. 
    
35.         int nfds   = 0;        
    
36.         int n      = 0;
    
37.         int status = 0;
    
38. 
    
39.         //lock_mutex = PTHREAD_MUTEX_INITIALIZER;
    
40. 
    
41. 
    
42.         status = pthread_create(&pid_t, NULL, work, NULL);  // 起一个线称建立连接
    
43. 
    
44.         if (0 == status) {               
    
45.                 printf(" pthread created \n");
    
46.         } else {
    
47.                 perror(" pthread create fail\n");
    
48.                 return 0;
    
49.         }
    
50. 
    
51. 
    
52.         epollfd  = epoll_create(maxevents);                   // 建立epoll
    
53. 
    
54.         if (-1 == epollfd){           
    
55.                 perror("error cannot epoll_create\n");
    
56.                 return 0;
    
57.         } else {
    
58.                 printf("epollfd = %d  \n", epollfd);
    
59.         }
    
60. 
    
61.         printf(" begin epoll_wait \n");
    
62. 
    
63.         for (;;) {
    
64. 
    
65.                 //printf("befor epoll_wait %d \n", &(events[0]));   
    
66.                 nfds = epoll_wait(epollfd, events, maxevents, 500); // 开始抓回复
    
67.                 printf(" after  epoll_wait nfds = %d\n", nfds);
    
68. 
    
69.                 if(nfds == -1){
    
70.                         perror("nfds == -1 ");
    
71.                         return 0;
    
72.                 }else {
    
73.                         printf("nfds = %d \n", nfds);
    
74.                 }
    
75. 
    
76.                 for(n = 0; n < nfds; ++n) {                       
    
77.                         do_use_fd(&(events[n]));
    
78.                 } // end for         
    
79.         } // end for        
    
80.         return 0;
    
81. }
    
82. 
    
83. 
    
84. 
    
85. void *work(void *arg){  // 这个就是工作线称主要发起连接
    
86. 
    
87.         int i = 0 ;
    
88.         int create_conn = 1;
    
89.         struct sockaddr_in clientadd;
    
90.         int client;
    
91.         struct epoll_event ev;
    
92.         int len = 0;
    
93. 
    
94.         pthread_detach(pthread_self());  // this
    
95. 
    
96. 
    
97.         for (;;){
    
98. 
    
99.                 create_conn = 1;
    
100.                 pthread_mutex_lock(&lock_mutex);
     
101. 
     
102.                 if (lines > max_connect){
     
103.                         create_conn = 0;                   
     
104.                 }
     
105.                 pthread_mutex_unlock(&lock_mutex);
     
106. 
     
107.                 if (0 == create_conn){
     
108.                         sleep(1);
     
109.                         continue;       
     
110.                 }
     
111. 
     
112.                 // else
     
113.                 client = socket(AF_INET , SOCK_STREAM, 0);
     
114.                 if (client < 0){
     
115.                         sleep(1);                  
     
116.                         continue;        
     
117.                 }
     
118. 
     
119.                 printf("begin memset \n");
     
120.                 memset(&clientadd, 0, sizeof(clientadd));
     
121. 
     
122.                 clientadd.sin_family = AF_INET;
     
123.                 clientadd.sin_addr.s_addr  =  inet_addr("192.168.1.150");  
     
124.                 clientadd.sin_port  = htons(80);
     
125.                 setnonblocking(client);
     
126. 
     
127.                 ev.events  =  EPOLLOUT;
     
128.                 ev.data.fd =  client;
     
129. 
     
130.                 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, client, &ev) < 0) {
     
131.                         printf(" fd = %d ", client);
     
132.                         perror("epoll set insertion error");                       
     
133.                         return NULL;
     
134. 
     
135.                 } else {               
     
136.                         printf(" add to %d epoll pool\n", epollfd);
     
137.                 }
     
138. 
     
139.                 printf("begin connect \n");
     
140. 
     
141.                 connect(client, (struct sockaddr*)&clientadd, sizeof(clientadd));
     
142.                 printf("begin connect \n");
     
143. 
     
144.                 pthread_mutex_lock(&lock_mutex);
     
145.                 ++lines;           
     
146.                 printf(" now lines = %d \n", lines);
     
147.                 pthread_mutex_unlock(&lock_mutex);
     
148. 
     
149.         } // end for
     
150. }
     
151. 
     
152. void setnonblocking(int sock){
     
153.         int opts;
     
154.         opts=fcntl(sock,F_GETFL);
     
155.         if(opts<0)
     
156.         {
     
157.                 perror("fcntl(sock,GETFL)");
     
158.                 exit(1);
     
159.         }
     
160. 
     
161.         opts = opts|O_NONBLOCK;
     
162.         if(fcntl(sock,F_SETFL,opts)<0)
     
163.         {
     
164.                 perror("fcntl(sock,SETFL,opts)");
     
165.                 exit(1);
     
166.         }
     
167. }
     
168. 
     
169. void do_use_fd(struct epoll_event   *events){
     
170. 
     
171. 
     
172.         struct epoll_event ev;
     
173.         int n  =  0;
     
174. 
     
175.         char buff[100] ="get / http/1.1\r\n\r\n";
     
176.         char inbuff[MAXLINE] ={0};
     
177.         int client = events->data.fd;
     
178.         int closeit = 1;
     
179. 
     
180.         printf(" in do user fd \n");
     
181. 
     
182.         if (events->events & EPOLLIN){ // 可以读了
     
183. 
     
184.                 if ( (client = events->data.fd) < 0) return;
     
185. 
     
186.                 while (1) {
     
187.                         if ( (n = read(client, inbuff, MAXLINE)) < 0) {
     
188. 
     
189.                                 if (errno == ECONNRESET) {
     
190. 
     
191.                                         printf("readline error  errno == ECONNRESET\n");                                       
     
192.                                         break;
     
193. 
     
194.                                 } else {
     
195. 
     
196.                                         printf("readline error no data \n");               
     
197.                                         closeit = 0;
     
198.                                         break;
     
199.                                 }
     
200. 
     
201.                         } else if (n == 0) {
     
202.                                 printf("readline == 0 \n");
     
203.                                 break;
     
204.                         } else {
     
205.                                 printf("i get %d byte form %d \n", n ,client);
     
206.                         }
     
207.                 } // end while (1)
     
208. 
     
209.                 if (1 == closeit) {
     
210.             printf("close socket %d now \n", client);
     
211.                         close(client);
     
212.                         ev.events = EPOLLIN |EPOLLERR;
     
213.                     ev.data.fd = client;
     
214.                     epoll_ctl(epollfd, EPOLL_CTL_DEL, client, &ev);  
     
215.        
     
216.                         pthread_mutex_lock(&lock_mutex);
     
217.                         --lines;           
     
218.                         printf(" now lines = %d \n", lines);
     
219.                         pthread_mutex_unlock(&lock_mutex);
     
220.                         return;
     
221.                 }
     
222.         }  else if (events->events & EPOLLOUT) // end if
     
223. 
     
224.          {
     
225.                 if ( (client = events->data.fd) < 0) return;
     
226.                 printf(" now write %d \n",events->data.fd);
     
227.                 n = write(events->data.fd, buff, strlen(buff));
     
228. 
     
229.                 printf("%d  write = %d \n", lines, n);
     
230.                 ev.events = EPOLLIN |EPOLLERR;
     
231.                 ev.data.fd = client;
     
232.                 epoll_ctl(epollfd, EPOLL_CTL_MOD, client, &ev);               
     
233.                 return;        
     
234.         }
     
235. 
     
236.         //close(events->data.fd); //读完了 就短掉连接
     
237. 
     
238. }

复制代码

本意是一个网络爬虫，不断去不同的服务器获取网页。 采用epoll 而不是多线称+简单的代码。

因为是爬虫 所以需要不断的发起连接。 这个连接可以在 epoll_wait 里面建立也可以起一个线程，在线程里面建立
我采用了后者。

目前的问题是，  只能运行一次。 当一条连结，建立，完成后，断开。 再次建立第二个连接 当使用的是上次被关闭的那个fd
程序就死了
help

redor

你需要把你的原有的event从epoll里边删除.