select、poll、epoll 比较

转载：http://blog.csdn.net/dodo_328/article/details/39081183

1.Selet：本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。

               缺点：1 单个进程可监视的fd数量被限制，因为受描述符集合fd_set限制，fd数量最大不超过1024；

                          2 需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时复制开销大；

                          3 对socket进行扫描时是线性扫描;

                          4 Linux的实现中select返回时会将timeout修改为剩余时间，所以重复利用timeout需要注意。

函数原型：int select(int nfds,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,struct timeval *timeout);

参数：nfds 需要监听的最大fd 值加1；

           readfds 等待从此集合中的文件描述符中到来的数据；

           writefds 等待向此集合中的文件描述符写入的数据；

           exceptfds 等待这些文件描述符操作的异常；

           timeout  超过此时间后函数返回。

返回值：-1  发生错误；

              0    超时；

             num   满足需求的文件描述符数目。

 

void FD_CLR(int fd,fd_set *set)：用来从文件描述符集合中删除一个文件描述符。

void FD_ISSET(int fd, fd_set *set)：用来测试在这个文件描述符集合中，此文件描述符是否被触发。

void FD_SET(int fd, fd_set *set)：用来将一个文件描述符设置到文件描述符集合中去。

void FD_ZERO(fd_set *set)：用来将文件描述符集合清零。

程序实例：

[objc]  view plain  copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<sys/time.h>  
4. #include<sys/types.h>  
5. #include<unistd.h>  
6. #include<fcntl.h>  
7.   
8. #define oops(m,x){perror(m);exit(x);}  
9. void showdata(charchar *,int );  
10.   
11. int main(int ac,charchar *av[])  
12. {  
13.     int fd1,fd2;  
14.     int max_fd;  
15.     fd_set readfds;  
16.     struct timeval timeout;  
17.     int retval;  
18.       
19.     if(ac != 4)  
20.     {  
21.         fprintf(stderr,"Usage:%s file1 file2 timeout\n",*av);  
22.         exit(1);  
23.     }  
24.   
25.     if((fd1 = open(av[1],O_RDONLY)) == -1)  
26.         oops("file1 open",2);  
27.   
28.     if((fd2 = open(av[2],O_RDONLY)) == -1)  
29.         oops("file2 open",3);  
30.   
31.     max_fd = 1 + ((fd1 > fd2)?fd1:fd2);  
32.   
33.     while(1)  
34.     {  
35.         FD_ZERO(&readfds);  
36.         FD_SET(fd1,&readfds);  
37.         FD_SET(fd2,&readfds);  
38.   
39.         timeout.tv_sec = atoi(av[3]);  
40.         timeout.tv_usec = 0;  
41.   
42.         retval = select(max_fd,&readfds,NULL,NULL,&timeout);  
43.   
44.         if(retval == -1)  
45.             oops("select",4);  
46.         if(retval > 0)  
47.         {  
48.             if(FD_ISSET(fd1,&readfds))  
49.                 showdata(av[1],fd1);  
50.             if(FD_ISSET(fd2,&readfds))  
51.                 showdata(av[2],fd2);  
52.         }  
53.         else  
54.             printf("no input after %d seconds\n",atoi(av[3]));  
55.     }  
56. }  
57.   
58. void showdata(charchar *fname,int fd)  
59. {  
60.     char buf[BUFSIZ];  
61.     int n;  
62.   
63.     printf("%s:",fname);  
64.     fflush(stdout);  
65.     n = read(fd,buf,BUFSIZ);  
66.     if(n == -1)  
67.         oops(fname,5);  
68.     write(1,buf,n);  
69.     write(1,"\n",1);  
70. }  

 

2.Poll:它将用户传入的数组拷贝到内核空间，然后查阅每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历，如果遍历完所有的fd没有发现设备就绪，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后，它又要再次遍历fd,这个过程经历了多次无谓的遍历。

          优点：没有最大链接数的限制，原因是因为它是基于链表来存储的；不会修改timeout的值。

          缺点：大量的fd数组被整体复制于用户态和内核地址空间之间。

          特点：“水平触发”：如果报告fd后，没有被处理，那么下次poll时会再次报告该fd。

struct pollfd{

       int fd;  //文件描述符

       short events;  //等待的事件

       short  revents; //实际发生的事件

}

函数原型：int poll(struct pollfd  fds[ ], nfds_t nfds,int timeout);

参数：fds[]  文件描述符以及等待的事件结构数组；

           nfds  表示监听的fds的长度；

           timeout 超时；

返回值：-1 发生错误；

              0   超时；

             num 满足需求的文件描述符总数。

events/revents：POLLIN|POLLOUT

程序实例：

[objc]  view plain  copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<unistd.h>  
4. #include<poll.h>  
5. #include<fcntl.h>  
6.   
7. #define oops(m,x){perror(m);exit(x);}  
8.   
9. void showdata(charchar *,int);   
10.   
11. int main(int ac,charchar *av[])  
12. {  
13.     int timeout,fd1,fd2;  
14.     struct pollfd poll_array[2];  
15.     //int i;  
16.     int ret;  
17.   
18.     if(ac != 4)  
19.     {  
20.         fprintf(stderr,"Usage:%s file1 file2 timeout\n",*av);  
21.         exit(1);  
22.     }  
23.   
24.     timeout = atoi(av[3]);  
25.   
26.     if((fd1 = open(av[1],O_RDONLY)) == -1)  
27.         oops(av[1],2);  
28.     if((fd2 = open(av[2],O_RDONLY)) == -1)  
29.         oops(av[2],3);  
30.   
31.     poll_array[0].fd = fd1;  
32.     poll_array[0].events = POLLIN;  
33.     poll_array[1].fd = fd2;  
34.     poll_array[1].events = POLLIN;  
35.   
36.     while(1)  
37.     {  
38.         ret = poll(poll_array,2,timeout);  
39.   
40.         if(ret == -1)  
41.             oops("poll error\n",1);  
42.         if(ret == 0)  
43.         {  
44.             printf("timeout..\n");  
45.             continue;  
46.         }  
47.   
48.         if(poll_array[0].revents & POLLIN)  
49.         {  
50.             showdata(av[1],fd1);  
51.         }  
52.   
53.         if(poll_array[1].revents &POLLIN)  
54.             showdata(av[2],fd2);  
55.     }  
56.     return 0;  
57. }  
58.   
59. void showdata(charchar *fname,int fd)  
60. {  
61.     char buf[BUFSIZ];  
62.     int n;  
63.   
64.     printf("%s:",fname);  
65.     fflush(stdout);  
66.     n = read(fd,buf,BUFSIZ);  
67.     printf("n:%d\n",n);  
68.     if(n == -1)  
69.         oops(fname,4);  
70.     write(1,buf,n);  
71.     write(1,"\n",1);  
72. }  

 

3.Epoll:解决了select和poll的几个性能上的缺陷

            1. 不限制监听的描述符个数，只受进程打开的描述符总数的限制；

            2. 监听性能不随着监听描述符数的增加而增加，是0(1)的，不再是轮询描述符来探测事件，而是描述符主动上报事件；

            3.使用共享内存的方式，不在用户和内核之间反复传递监听的描述信息；

            4.返回参数就是触发事件的列表，不再遍历。

            注意：1.epoll创建了描述符，最后要close(epfd);

                       2.支持水平和边缘触发。

int epoll_creat(int size)

功能：用来创建epoll文件描述符。

参数：size 能在epoll上关注的最大fd数。

返回值：epfd。

int epoll_ctl(int epfd,int op,int fd, struct epoll_event *event)

功能：控制对指定的文件描述符执行op操作。

参数：epfd  epoll_creat()函数的返回值。

           op  EPOLL_CTL_ADD(增加)/EPOLL_CTL_DEL(删除)/EPOLL_CTL_MOD(修改)。

           fd   文件描述符。

           event  与fd 相关联的监听事件。

struct  epoll_event{

           _uint32_t  events;

           epoll_data_t  data;

};

events:EPOLLIN 可读。

            EPOLLOUT 可写。

            EPOLLRDHUP 套接口对端close或shutdown写，在ET（边缘）模式下比较有用。

            EPOLLET 边缘触发模式，在描述符状态跳变时才上报监听事件（监听默认是LT（水平）模式）。

            EPOLLPRI 紧急数据可读。

            EPOLLERR 异常事件。

            EPOLLHUP 挂起。 EPOLLERR 和EPOLLHUP始终由epoll_wait监听，不需要用户设置。

            EPOLLONESHOT  只一次有效，描述符在触发一次事件之后自动失效。fd还在继续监听，直到使用EPOLL_CTL_MOD重新激活，设置新的监听事件。

data: 是个共用体，可以存放和fd绑定的描述符信息。比如ip/port等。

typedef  union  epoll_data{

          void *ptr;//存放与fd绑定的信息。

          int fd;

          _uint32_t  u32;

          _uint32_t  u64;

}epoll_data_t;

int epoll_wait(int epfd,struct epoll_event *events,int maxevents, int timeout)

参数：epfd  epoll_creat()的返回值.

           events  用于回传待处理事件的数组，值结果参数。

           maxevents  每次能处理的事件数。

           timeout  超时设置。

返回值：-1  发生错误；

              0   超时；

             num  触发事件的描述符总数。

程序实例：

[objc]  view plain  copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<poll.h>  
4. #include<unistd.h>  
5. #include<fcntl.h>  
6. #include<sys/types.h>  
7. #include<sys/epoll.h>  
8.   
9. #define oops(m,x){perror(m);exit(x);}  
10. #define MAX_SIZE_EVENT  500  
11.   
12. void showdata(int ,charchar *);  
13.   
14. int main(int ac ,charchar *av[])  
15. {  
16.     int fd1,fd2;  
17.     int time;  
18.     int epfd;  
19.     struct epoll_event eventList[MAX_SIZE_EVENT];  
20.     struct epoll_event fd1_event;  
21.     struct epoll_event fd2_event;  
22.     int ret;  
23.     int n ;  
24.       
25.     if(ac != 4)  
26.     {  
27.         fprintf(stderr,"Usage:%s file1 file2 timeout\n",*av);  
28.         exit(1);  
29.     }  
30.   
31.     if((fd1 = open(av[1],O_RDONLY)) == -1)  
32.         oops("file1 open",2);  
33.     if((fd2 = open(av[2],O_RDONLY)) == -1)  
34.         oops("file2 open",3);  
35.       
36.     time = atoi(av[3]);  
37.   
38.     epfd = epoll_create(MAX_SIZE_EVENT);  
39.     fd1_event.events = EPOLLIN|EPOLLET;  
40.     fd1_event.data.fd = fd1;  
41.     fd1_event.data.ptr = av[1];  
42.     fd2_event.events = EPOLLIN|EPOLLET;  
43.     fd2_event.data.fd = fd2;  
44.     fd2_event.data.ptr = av[2];  
45.   
46.     if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&fd1_event) < 0)  
47.         oops("fd1_event epoll addfail",4);  
48.     if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&fd2_event) < 0)  
49.         oops("fd2_event epoll addfail",5);  
50.   
51.     while(1)  
52.     {  
53.         ret = epoll_wait(epfd,eventList,MAX_SIZE_EVENT,time);  
54.         if(ret < 0)  
55.             oops("epoll error",6);  
56.         if(ret == 0)  
57.         {  
58.             printf("timeout\n");  
59.         }  
60.   
61.         for(n = 0;n < ret; n++)  
62.         {  
63.             if(eventList[n].events & EPOLLERR || eventList[n].events & EPOLLHUP || !(eventList[n].events & EPOLLIN))  
64.             {  
65.                 printf("epoll error");  
66.                 close(epfd);  
67.                 close(eventList[n].data.fd);  
68.                 return -1;  
69.             }  
70.             else if(eventList[n].events & EPOLLIN)  
71.                 showdata(eventList[n].data.fd,eventList[n].data.ptr);  
72.         }  
73.   
74.     }  
75.     close(epfd);  
76.     close(fd1);  
77.     close(fd2);  
78.     return 0;  
79. }  
80.   
81. void showdata(int fd,charchar *fname)  
82. {  
83.     char buf[BUFSIZ];  
84.     int n;  
85.   
86.     printf("%s:",fname);  
87.     fflush(stdout);  
88.   
89.     n = read(fd,buf,BUFSIZ);  
90.     if(n == -1)  
91.         oops("fd read",6);  
92.     write(1,buf,n);  
93.     write(1,"\n",1);  
94. }