linux 网络编程 I/O复用 select，poll ,epoll

http://blog.csdn.net/zs634134578/article/details/19929449

问题聚焦：

    前篇提到了I/O处理单元的四种I/O模型。

    本篇详细介绍实现这些I/O模型所用到的相关技术。

    核心思想：I/O复用

使用情景：

• 客户端程序要同时处理多个socket
• 客户端程序要同时处理用户输入和网络连接
• TCP服务器要同时处理监听socket和连接socket，这是使用最多的场合
• 服务器要同时可处理TCP请求和UDP请求
• 服务器要同时监听多个端口

主要技术：

• select
• poll
• epoll

select系统调用

作用：

    在一段指定时间内，监听用户感兴趣的文件描述符的可读、可写和异常等事件。

select API

原型:

[cpp] view plaincopy

1. #include <sys/select.h>
2. int select ( int nfds, fd_set* readfds, fde_set* writefds, fd_set* exceptfds, struct timeval* timeout );  

函数说明：

nfds：指定被监听的文件描述符的总数，通常为所有文件描述符中的最大值+1

readfds, writefds, exceptfds：可读、可写和异常等事件对应的文件描述符集合。

fd_set结构：仅包含一个整型数组，该数组的每个元素的每一位标记了一个文件描述符。fd_set能容纳的文件描述符数量由FD_SETSIZE指定，这就限制了select能同时处理的文件描述符的总量。

fd_set相关的位操作：

[cpp] view plaincopy

1. #include <sys/select.h>
2. FD_ZERO( fd_set *fdset );  
3. FD_SET( int fd, fd_set *fdset );  
4. FD_CLR( int fd, fd_set *fdset );  
5. int FD_ISSET( int fd, fd_set *fdset );  

timeout：设置select函数的超时时间

返回状态：

select成功时返回就绪（可读、可写和异常）文件描述符的总数。

如果在超时时间内没有任何文件描述符就绪，select将返回0.

select失败时返回-1并设置errno

如果select 等待期间，程序接收到信号，则select立即返回-1，并设置errno为EINTR。

文件描述符就绪条件

可读：

• socket内核接收缓冲区中的字节数大于或等于其低水位标记SO_RCVLOWAT。此时我们可以无阻塞地对该socket，并且读操作返回的字节数大于0
• socket通信的对方关闭连接，此时读操作返回0
• 监听socket上有新的连接请求
• socekt上有未处理的错误，此时我们可以使用getsockopt来读取和清除该错误。

可写：

• socket内核发送缓冲区中的可用字节数大于或等于其低水位标记SO_SNDLOWAT。此时我们可以无阻塞地写该socket，并且写操作返回的字节数大于0
• socket的写操作被关闭。对写操作被关闭的socket执行写操作将出发一个SIGPIPE信号
• socket使用非阻塞connect连接成功或者失败之后
• socket上有未处理的错误，此时我们可以使用getsockopt来读取和清除该错误。

异常：

• socket上接收到带外数据

处理带外数据

socket上接收到普通数据和带外数据都将使select返回，但socket处于不同的就绪状态：前者处于可读状态，后者处于异常状态。

[cpp] view plaincopy

1. #include <sys/types.h>
2. #include <sys/socket.h>
3. #include <netinet/in.h>
4. #include <arpa/inet.h>
5. #include <assert.h>
6. #include <stdio.h>
7. #include <unistd.h>
8. #include <errno.h>
9. #include <string.h>
10. #include <fcntl.h>
11. #include <stdlib.h>
13. int main( int argc, char* argv[] )  
14. {  
15. if( argc <= 2 )  
16.         {  
17.             printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );  
18. return 1;      
19.         }  
20. const char* ip = argv[1];  
21. int port = atoi( argv[2] );  
22.         printf( "ip is %s and port is %d\n", ip, port );  
24. int ret = 0;  
25. struct sockaddr_in address;  
26.         bzero( &address, sizeof( address ) );  
27.         address.sin_family = AF_INET;  
28.         inet_pton( AF_INET, ip, &address.sin_addr );  
29.         address.sin_port = htons( port );  
31. int listenfd = socket( PF_INET, SOCK_STREAM, 0 );  
32.         assert( listenfd >= 0 );  
34.         ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );  
35.         assert( ret != -1 );  
37.         ret = listen( listenfd, 5 );  
38.         assert( ret != -1 );  
40. struct sockaddr_in client_address;  
41.         socklen_t client_addrlength = sizeof( client_address );  
42. int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );  
43. if ( connfd < 0 )  
44.         {  
45.              printf( "errno is: %d\n", errno );  
46.              close( listenfd );  
47.         }  
49. char remote_addr[INET_ADDRSTRLEN];  
50.         printf( "connected with ip: %s and port: %d\n",  
51.                  inet_ntop( AF_INET, &client_address.sin_addr, remote_addr, INET_ADDRSTRLEN ),   
52.                 ntohs( client_address.sin_port ) );  
54. char buf[1024];  
55.         fd_set read_fds;  
56.         fd_set exception_fds;  
58.         FD_ZERO( &read_fds );  
59.         FD_ZERO( &exception_fds );  
61. int nReuseAddr = 1;  
62.         setsockopt( connfd, SOL_SOCKET, SO_OOBINLINE, &nReuseAddr, sizeof( nReuseAddr ) );  
63. while( 1 )  
64.         {  
65.             memset( buf, '\0', sizeof( buf ) );     
66. /* 每次调用select前都要重新在readfds和exception_fds中设置文件描述符connfd，因为事件发生之后，文件描述符集合将被内核修改 */
67.             FD_SET( connfd, &read_fds );  
68.             FD_SET( connfd, &exception_fds );  
70.             ret = select( connfd + 1, &read_fds, NULL, &exception_fds, NULL );  
71.             printf( "select one\n" );  
72. if ( ret < 0 )  
73.             {  
74.                  printf( "selection failure\n" );  
75. break;  
76.             }  
78. /* 对于可读事件，采用普通的recv函数读取数据 */
79. if ( FD_ISSET( connfd, &read_fds ) )  
80.             {  
81.                 ret = recv( connfd, buf, sizeof( buf )-1, 0 );  
82. if( ret <= 0 )  
83.                 {  
84. break;  
85.                 }  
86.                 printf( "get %d bytes of normal data: %s\n", ret, buf );  
87.             }  
88. /* 对于异常事件，采用带MSG_OOB标志的recv函数读取带外数据 */
89. else if( FD_ISSET( connfd, &exception_fds ) )  
90.             {  
91.                 ret = recv( connfd, buf, sizeof( buf )-1, MSG_OOB );  
92. if( ret <= 0 )  
93.                 {  
94. break;  
95.                 }  
96.                 printf( "get %d bytes of oob data: %s\n", ret, buf );  
97.              }  
99.         }  
101.  close( connfd );  
102.  close( listenfd );  
103. return 0;  
104. }  

poll系统调用

作用：和select类型，也是在指定时间内轮询一定数量的文件描述符，以测试其中是否有就绪者。

原型：

[cpp] view plaincopy

1. #include <poll.h>
2. int poll ( struct pollfd* fds, nfds_t nfds, int timeout );  

函数说明：

fds：指定我们所感兴趣的文件描述符上发生的可读，可写和异常事件。

pllfd结构：

[cpp] view plaincopy

1. struct pollfd  
2. {  
3. int fd;                /* 文件描述符 */
4. short events;    /* 注册的事件 */
5. short revents;    /* 实际发生的事件，由内核填充 */
6. }  

支持的事件类型：(自行百度)

返回值：通常，应用程序需要根据recv调用的返回值来区分socket上接收到的是有效数据还是对方关闭连接的请求，并做相应的处理。poll系统调用的返回值的含义与select相同。

nfds：指定被监听事件集合fds的大小。

类型nfds_t定义：

[cpp] view plaincopy

1. typedef unsigned long int nfds_t;  

timeout：指定poll的超时值，单位是毫秒。当timeout为-1时，poll调用将永远阻塞，直到某个事件发生。当timeout为0时，poll调用将立即返回。

epoll系列系统调用

特点：

    一组函数完成任务

    epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，从而无须像select和poll那样每次调用都要重复传入文件描述符集或事件集。

    需要一个额外的文件描述来唯一标识内核中的这个事件表。

文件描述符的创建：

[cpp] view plaincopy

1. #include <sys/epoll.h>
2. int epoll_create ( int size );  

该函数返回的文件描述符将用作其他所有epoll系统调用的第一个参数，以指定要访问的内核事件表。

操作内核事件表：

[cpp] view plaincopy

1. #include <sys/epoll.h>
2. int epoll_ctl ( int epfd, int op, int fd, struct epoll_event *event );  

函数说明：

fd：要操作的文件描述符

op：指定操作类型

操作类型：

    EPOLL_CTL_ADD：往事件表中注册fd上的事件

    EPOLL_CTL_MOD：修改fd上的注册事件

    EPOLL_CTL_DEL：删除fd上的注册事件

event：指定事件，它是epoll_event结构指针类型

epoll_event定义：

[cpp] view plaincopy

1. struct epoll_event  
2. {  
3.     __unit32_t events;    /* epoll事件 */
4.     epoll_data_t data;    /* 用户数据 */
5. };  

结构体说明：

events：描述事件类型，和poll支持的事件类型基本相同（两个额外的事件：EPOLLET和EPOLLONESHOT，高效运作的关键）

data成员：存储用户数据

[cpp] view plaincopy

1. typedef union epoll_data  
2. {  
3. void* ptr;              /* 指定与fd相关的用户数据 */
4. int fd;                   /* 指定事件所从属的目标文件描述符 */
5.     uint32_t u32;  
6.     uint64_t u64;  
7. } epoll_data_t;  

epoll_wait函数

主要接口

作用：在一段时间内，等待一组文件描述符上的事件

原型：

[cpp] view plaincopy

1. #include <sys/epoll.h>
2. int epoll_wait ( int epfd, struct epoll_event* events, int maxevents, int timeout );  

函数说明：

返回：成功时返回就绪的文件描述符的个数，失败时返回-1并设置errno

timeout：与poll相同

maxevents：指定最多监听多少个事件

events：检测到事件，将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中。与poll的区别（见下面的demo）

poll和epoll在使用上的差别：

[cpp] view plaincopy

1. /* 索引poll返回的就绪文件描述符 */
2. /* 方式：遍历，检查标志位 */
3. int ret = poll ( fds, MAX_EVENT_NUMBER, -1 );  
4. for ( int i = 0; i < MAX_EVENT_NUMBER; ++i )  
5. {  
6. if ( fds[i].revents & POLLIN )  
7.     {  
8. int sockfd = fds[i].fd;  
9. /* 处理sockfd */
10.     }  
11. }  
13. /*  索引epoll返回的就绪文件描述符 */
14. /* 方式：遍历 */
15. int ret = epoll_wait ( epollfd, events, MAX_EVENT_NUMBER, -1 );  
16. for ( int i = 0; i < ret; i++ )  
17. {  
18. int sockfd = events[i].data.fd;  
19. /* sockfd必然就绪，直接处理 */
20. }  

LT和ET模式

对文件操作符的操作模式：

• LT：电平触发，默认的工作模式，检测到有事件发生可以不立即处理。
• ET：边沿触发，搞笑工作模式，文件描述符注册为EPOLLET事件，检测到有事件发生立即处理，后续epoll_wait不再向应用程序通知这一事件。

区别：ET模式在很大程度上降低了同一个epoll事件被重复出发的参数，因此效率要比LT模式高。

EPOLLONESHOT事件

使用场合：

    一个线程在读取完某个socket上的数据后开始处理这些数据，而数据的处理过程中该socket又有新数据可读，此时另外一个线程被唤醒来读取这些新的数据。

    于是，就出现了两个线程同时操作一个socket的局面。

    可以使用epoll的EPOLLONESHOT事件实现一个socket连接在任一时刻都被一个线程处理。

作用：

    对于注册了EPOLLONESHOT事件的文件描述符，操作系统最多出发其上注册的一个可读，可写或异常事件，且只能触发一次。

使用：

    注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下一次可读时，其EPOLLIN事件能被触发，进而让其他工作线程有机会继续处理这个sockt。

效果：

尽管一个socket在不同事件可能被不同的线程处理，但同一时刻肯定只有一个线程在为它服务，这就保证了连接的完整性，从而避免了很多可能的竞态条件。

小结：三组I/O复用函数的比较

需要说明的是：

epoll的效率未必一定比select和poll高。

当活动连接比较多的时候，回调函数被触发得过于频繁，而降低效率。

所以，epoll_wait适用于连接数量多，但活动连接较少的情况。

参考资料：

《Linux高性能服务器编程》