谁能够帮我解释一下，linux下使用epoll的例子

yuonunix

谁能够帮我解释一下，linux下使用epoll的例子，这个例子中，兰山部分没有看明白：

为什么收到“EPOLLIN”，即有数据需要读取，read之后，还要修改要处理的事件为EPOLLOUT呢？



for ( ; ; ) {
          //等待epoll事件的发生
          nfds=epoll_wait(epfd,events,20,500);
          //处理所发生的所有事件      
          for(i=0;i<nfds;++i)
          {
               if(events.data.fd==listenfd)
               {

                    connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
                    if(connfd<0){
                         perror("connfd<0");
                         exit(1);
                    }
                    setnonblocking(connfd);

                    char *str = inet_ntoa(clientaddr.sin_addr);
                    std::cout<<"connect from "<_u115 ?tr<<std::endl;
                    //设置用于读操作的文件描述符
                    ev.data.fd=connfd;
                    //设置用于注测的读操作事件
                    ev.events=EPOLLIN|EPOLLET;
                    //注册ev
                    epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
               }
               else if(events.events&EPOLLIN)
               {
                    if ( (sockfd = events.data.fd) < 0) continue;
                    if ( (n = read(sockfd, line, MAXLINE)) < 0) {
                         if (errno == ECONNRESET) {

                              close(sockfd);
                              events.data.fd = -1;
                         } else
                              std::cout<<"readline error"<<std::endl;
                    } else if (n == 0) {
                         close(sockfd);
                         events.data.fd = -1;
                    }
                    //设置用于写操作的文件描述符
                    ev.data.fd=sockfd;
                    //设置用于注测的写操作事件
                    ev.events=EPOLLOUT|EPOLLET;
                    //修改sockfd上要处理的事件为EPOLLOUT
                    epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
               }
               else if(events.events&EPOLLOUT)
               {   
                    sockfd = events.data.fd;
                    write(sockfd, line, n);
                    //设置用于读操作的文件描述符
                    ev.data.fd=sockfd;
                    //设置用于注测的读操作事件
                    ev.events=EPOLLIN|EPOLLET;
                    //修改sockfd上要处理的事件为EPOLIN
                    epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
               }

          }

     }
}

cugb_cat

我的博客中有点东西，或许对你理解epoll有帮助

M.I.X

这个需要根据具体情况使用
如果这个fd你只读不写，完全可以不用改为EPOLLOUT

看我收集的这个模型，更容易理解一些：

1. 
   
2. #include <iostream>
   
3. #include <sys/socket.h>
   
4. #include <sys/epoll.h>
   
5. #include <netinet/in.h>
   
6. #include <arpa/inet.h>
   
7. #include <fcntl.h>
   
8. #include <unistd.h>
   
9. #include <stdio.h>
   
10. #include <pthread.h>
    
11. 
    
12. #define MAXLINE 10
    
13. 
    
14. #define OPEN_MAX 100
    
15. 
    
16. #define LISTENQ 20
    
17. 
    
18. #define SERV_PORT 5555
    
19. 
    
20. #define INFTIM 1000
    
21. 
    
22. 
    
23. //线程池任务队列结构体
    
24. 
    
25. struct task{
    
26.   int fd;            //需要读写的文件描述符
    
27. 
    
28.   struct task *next; //下一个任务
    
29. 
    
30. };
    
31. 
    
32. //用于读写两个的两个方面传递参数
    
33. 
    
34. struct user_data{
    
35.   int fd;
    
36.   unsigned int n_size;
    
37.   char line[MAXLINE];
    
38. };
    
39. 
    
40. //线程的任务函数
    
41. 
    
42. void * readtask(void *args);
    
43. 
    
44. void * writetask(void *args);
    
45. 
    
46. 
    
47. //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
    
48. 
    
49. struct epoll_event ev,events[20];
    
50. 
    
51. int epfd;
    
52. 
    
53. pthread_mutex_t mutex;
    
54. 
    
55. pthread_cond_t cond1;
    
56. 
    
57. struct task *readhead=NULL,*readtail=NULL,*writehead=NULL;
    
58. 
    
59. 
    
60. void setnonblocking(int sock)
    
61. {
    
62.      int opts;
    
63.      opts=fcntl(sock,F_GETFL);
    
64.      if(opts<0)
    
65.      {
    
66.           perror("fcntl(sock,GETFL)");
    
67.           exit(1);
    
68.      }
    
69.     opts = opts|O_NONBLOCK;
    
70.      if(fcntl(sock,F_SETFL,opts)<0)
    
71.      {
    
72.           perror("fcntl(sock,SETFL,opts)");
    
73.           exit(1);
    
74.      }   
    
75. }
    
76. 
    
77. 
    
78. int main()
    
79. {
    
80.      int i, maxi, listenfd, connfd, sockfd,nfds;
    
81.      pthread_t tid1,tid2;
    
82.    
    
83.      struct task *new_task=NULL;
    
84.      struct user_data *rdata=NULL;
    
85.      socklen_t clilen;
    
86.    
    
87.      pthread_mutex_init(&mutex,NULL);
    
88.      pthread_cond_init(&cond1,NULL);
    
89.      //初始化用于读线程池的线程
    
90. 
    
91.      pthread_create(&tid1,NULL,readtask,NULL);
    
92.      pthread_create(&tid2,NULL,readtask,NULL);
    
93.    
    
94.      //生成用于处理accept的epoll专用的文件描述符   
    
95.      epfd=epoll_create(256);
    
96. 
    
97.      struct sockaddr_in clientaddr;
    
98.      struct sockaddr_in serveraddr;
    
99.      listenfd = socket(AF_INET, SOCK_STREAM, 0);
    
100.      //把socket设置为非阻塞方式
     
101. 
     
102.      setnonblocking(listenfd);
     
103.      //设置与要处理的事件相关的文件描述符
     
104. 
     
105.      ev.data.fd=listenfd;
     
106.      //设置要处理的事件类型
     
107. 
     
108.      ev.events=EPOLLIN|EPOLLET;
     
109.      //注册epoll事件
     
110. 
     
111.      epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
     
112.    
     
113.      bzero(&serveraddr, sizeof(serveraddr));
     
114.      serveraddr.sin_family = AF_INET;
     
115.    
     
116.      char *local_addr="200.200.200.222";
     
117.      inet_aton(local_addr,&(serveraddr.sin_addr));//htons(SERV_PORT);
     
118.      serveraddr.sin_port=htons(SERV_PORT);
     
119.      bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
     
120.      listen(listenfd, LISTENQ);
     
121.    
     
122.      maxi = 0;
     
123.      for ( ; ; ) {
     
124.           //等待epoll事件的发生
     
125. 
     
126.           nfds=epoll_wait(epfd,events,20,500);
     
127.           //处理所发生的所有事件     
     
128.         for(i=0;i<nfds;++i)
     
129.         {
     
130.                if(events[i].data.fd==listenfd)
     
131.                {
     
132.                   
     
133.                     connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
     
134.                     if(connfd<0){
     
135.                       perror("connfd<0");
     
136.                       exit(1);
     
137.                    }
     
138.                     setnonblocking(connfd);
     
139.                   
     
140.                     char *str = inet_ntoa(clientaddr.sin_addr);
     
141.                     std::cout<<"connec_ from >>"<<str<<std::endl;
     
142.                     //设置用于读操作的文件描述符
     
143. 
     
144.                     ev.data.fd=connfd;
     
145.                     //设置用于注测的读操作事件
     
146. 
     
147.                  ev.events=EPOLLIN|EPOLLET;
     
148.                     //注册ev
     
149. 
     
150.                  epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
     
151.                }
     
152.             else if(events[i].events&EPOLLIN)
     
153.             {
     
154.                     printf("reading!\n");               
     
155.                     if ( (sockfd = events[i].data.fd) < 0) continue;
     
156.                     new_task=new task();
     
157.                     new_task->fd=sockfd;
     
158.                     new_task->next=NULL;
     
159.                     //添加新的读任务
     
160. 
     
161.                     pthread_mutex_lock(&mutex);
     
162.                     if(readhead==NULL)
     
163.                     {
     
164.                       readhead=new_task;
     
165.                       readtail=new_task;
     
166.                     }   
     
167.                     else
     
168. 
     
169.                     {   
     
170.                      readtail->next=new_task;
     
171.                       readtail=new_task;
     
172.                     }   
     
173.                    //唤醒所有等待cond1条件的线程
     
174. 
     
175.                     pthread_cond_broadcast(&cond1);
     
176.                     pthread_mutex_unlock(&mutex);  
     
177.               }
     
178.                else if(events[i].events&EPOLLOUT)
     
179.                {   
     
180.               rdata=(struct user_data *)events[i].data.ptr;
     
181.                  sockfd = rdata->fd;
     
182.                  write(sockfd, rdata->line, rdata->n_size);
     
183.                  delete rdata;
     
184.                  //设置用于读操作的文件描述符
     
185. 
     
186.                  ev.data.fd=sockfd;
     
187.                  //设置用于注测的读操作事件
     
188. 
     
189.                ev.events=EPOLLIN|EPOLLET;
     
190.                  //修改sockfd上要处理的事件为EPOLIN
     
191. 
     
192.                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
     
193.                }
     
194.                              
     
195.           }
     
196.          
     
197.      }
     
198. }
     
199. 
     
200. void * readtask(void *args)
     
201. {
     
202.    
     
203.    int fd=-1;
     
204.    unsigned int n;
     
205.    //用于把读出来的数据传递出去
     
206. 
     
207.    struct user_data *data = NULL;
     
208.    while(1){
     
209.         
     
210.         pthread_mutex_lock(&mutex);
     
211.         //等待到任务队列不为空
     
212. 
     
213.         while(readhead==NULL)
     
214.              pthread_cond_wait(&cond1,&mutex);
     
215.         
     
216.         fd=readhead->fd;
     
217.         //从任务队列取出一个读任务
     
218. 
     
219.         struct task *tmp=readhead;
     
220.         readhead = readhead->next;
     
221.         delete tmp;
     
222.         pthread_mutex_unlock(&mutex);
     
223.         data = new user_data();
     
224.         data->fd=fd;
     
225.         if ( (n = read(fd, data->line, MAXLINE)) < 0) {
     
226.            
     
227.            if (errno == ECONNRESET) {
     
228.              close(fd);
     
229.             
     
230.           } else
     
231. 
     
232.              std::cout<<"readline error"<<std::endl;
     
233.            if(data!=NULL)delete data;
     
234.         } else if (n == 0) {
     
235.             close(fd);
     
236.            printf("Client close connect!\n");
     
237.            if(data!=NULL)delete data;
     
238.         } else{
     
239.         
     
240.         data->n_size=n;
     
241.         //设置需要传递出去的数据
     
242. 
     
243.         ev.data.ptr=data;
     
244.         //设置用于注测的写操作事件
     
245. 
     
246.         ev.events=EPOLLOUT|EPOLLET;
     
247.         //修改sockfd上要处理的事件为EPOLLOUT
     
248. 
     
249.         epoll_ctl(epfd,EPOLL_CTL_MOD,fd,&ev);
     
250.        }
     
251.    }
     
252. }
     
253. 
     
254. 
     

复制代码

baohuaihuai

恩,和具体实现是有关的.

little_apple

爆发式的连接，并且客户端都活跃时，如果用LT模式，两个vepoll_wait之间时间会比较长。
可以采用一个线程用一个select来处理listenhandle，另外一个线程用epoll来处理余下的客户端。