epoll学习笔记

注:内容皆是摘录 

Linux 2.6内核完全支持epoll. 

epoll的IO效率不随FD数目增加而线性下降 

传统的select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。 

内核实现中epoll是根据每个fd上面的callback函数实现的。只有"活跃"的socket才会主 

动的去调用 callback函数，其他idle状态socket则不会。 

如果所有的socket基本上都是活跃的---比如一个高速LAN环境，过多使用epoll,效率 

相比还有稍微的下降。 

但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。 


poll的执行分三部分： 
1.将用户传入的pollfd数组拷贝到内核空间，因为拷贝操作和数组长度相关，时间 

上这是一个O（n）操作 

2. 
查询每个文件描述符对应设备的状态，如果该设备尚未就绪，则在该设备的等 

待队列中加入一项并继续查询下一设备的状态。 
查询完所有设备后如果没有一个设备就绪，这时则需要挂起当前进程等待，直 

到设备就绪或者超时。 
设备就绪后进程被通知继续运行，这时再次遍历所有设备，以查找就绪设备。 
这一步因为两次遍历所有设备，时间复杂度也是O（n），这里面不包括等待时 

间。。  

3. 
将获得的数据传送到用户空间并执行释放内存和剥离等待队列等善后工作，向 

用户空间拷贝数据与剥离等待队列等操作的的时间复杂度同样是O（n）。 

epoll用到的所有函数都是在头文件sys/epoll.h中声明的，下面简要说明所用到的数 

据结构和函数： 
所用到的数据结构 
typedef union epoll_data { 
                void *ptr; 
                int fd; 
                __uint32_t u32; 
                __uint64_t u64; 
        } epoll_data_t; 

        struct epoll_event { 
                __uint32_t events;      /* Epoll events */ 
                epoll_data_t data;      /* User data variable */ 
        }; 
结构体epoll_event 被用于注册所感兴趣的事件和回传所发生待处理的事件. 

其中epoll_data 联合体用来保存触发事件的某个文件描述符相关的数据. 

例如一个client连接到服务器，服务器通过调用accept函数可以得到于这个client对 

应的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段以便后面的读 

写操作在这个文件描述符上进行。epoll_event 结构体的events字段是表示感兴趣的 

事件和被触发的事件可能的取值为： 
EPOLLIN ：表示对应的文件描述符可以读； 
EPOLLOUT：表示对应的文件描述符可以写； 
EPOLLPRI：表示对应的文件描述符有紧急的数据可读 
EPOLLERR：表示对应的文件描述符发生错误； 
EPOLLHUP：表示对应的文件描述符被挂断； 
EPOLLET：表示对应的文件描述符有事件发生； 



所用到的函数： 
1、int epoll_create(int size) 
   该函数生成一个epoll专用的文件描述符，其中的参数是指定生成描述符的最大 

范围 
    
2、 
用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。 
如果调用成功返回0,不成功返回-1 
int epoll_ctl( 
    int epfd,//由 epoll_create 生成的epoll专用的文件描述符 
    int op,//要进行的操作例如注册事件，可能的取值EPOLL_CTL_ADD 注册、 

EPOLL_CTL_MOD 修改、EPOLL_CTL_DEL 删除 
    int fd,//关联的文件描述符 
    struct epoll_event *event//指向epoll_event的指针 
    ) 
    
3、 
用于轮询I/O事件的发生 
返回发生事件数 
int epoll_wait( 
    int epfd,//由epoll_create 生成的epoll专用的文件描述符 
    struct epoll_event * events,//用于回传代处理事件的数组 
    int maxevents,//每次能处理的事件数 
    int timeout//等待I/O事件发生的超时值 
               //为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件 
               //为任意正整数的时候表示等这么长的时间，如果一直没有事件 
               //一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以 

保证一些效率 
               //如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率 

。 
    ) 

用法示例 

Java代码  

1. struct epoll_event ev, *events;  
2.   
3. for(;;) {  
4.     nfds = epoll_wait(kdpfd, events, maxevents, -1);/*wait for an I/O event. */  
5.   
6.     for(n = 0; n < nfds; ++n) {  
7.         if(events[n].data.fd == listener) {/*if listen socket has an I/O, accept the new connect*/  
8.             client = accept(listener, (struct sockaddr *) &local,  
9.                             &addrlen);  
10.             if(client < 0){  
11.                 perror("accept");  
12.                 continue;  
13.             }  
14.             setnonblocking(client);  
15.             ev.events = EPOLLIN | EPOLLET;/*EPOLLIN-available for read*/  
16.             ev.data.fd = client;  
17.             if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client, &ev) < 0) {/*add the new socket into the  
18.  
19. ile descriptors*/  
20.                 fprintf(stderr, "epoll set insertion error: fd=%d\n",  
21.                         client);  
22.                 return -1;  
23.             }  
24.         }  
25.         else  
26.             do_use_fd(events[n].data.fd);/*read from a socket which has data come*/  
27.     }  
28. }  

代码2

Java代码  

1. static int        s_epfd;//epoll描述字  
2.   
3. {//初始化epoll  
4.         struct epoll_event        ev;  
5.   
6.         //设置epoll  
7.         s_epfd = epoll_create(65535);  
8.   
9.         {//这个过程可以循环以便加入多个LISTEN套接字进入epoll事件集合  
10.                 //服务器监听创建  
11.                 rc = listen();//listen参数这里省略  
12.   
13.                 //加入epoll事件集合  
14.                 ev.events = EPOLLIN;  
15.                 ev.data.fd = rc;  
16.                 if (epoll_ctl(s_epfd, EPOLL_CTL_ADD, rc, &ev) < 0) {  
17.                         fprintf(stderr, "epoll set insertion error: fd=%d", rc);  
18.                         return(-1);  
19.                 }  
20.         }  
21. }  
22.   
23. {//epoll事件处理  
24.         int        i, nfds, sock_new;  
25.         struct epoll_event        events[16384];  
26.         for( ; ; ) {  
27.                 //等待epoll事件  
28.                 nfds = epoll_wait(s_epfd, events, 16384, -1);  
29.                 //处理epoll事件  
30.                 for(i = 0; i < nfds; i++) {  
31.                         //events[i].data.fd是epoll事件中弹出的套接字  
32.                         //接收连接  
33.                         sock_new = accept(events[i].data.fd);//accept其它参数这里省略了  
34.                         if(0 > sock_new) {  
35.                                 fprintf(stderr, "接收客户端连接失败\n");  
36.                                 continue;  
37.                         }  
38.                 }  
39.         }  
40. }  

代码3 

Java代码  

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