Linux C编程(十一) 之 I/O复用-----epoll机制
基础知识
I/O多路复用有很多种实现。在linux上，2.4内核前主要是select和poll，自Linux 2.6内核正式引入epoll以来，因为其可以轻松的处理上万个连接，性能卓越，已经成为了目前实现高性能网络服务器的必备技术。
函数解释
1. epoll_create
int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
2. epoll_ctl
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
EPOLLONESHOT
即使我们使用ET模式 ，一个socket上的某个事件还是有可能被触发多次，有可能出现多个线程同时处理一个socket的情况，这当然不是我们愿意看到的情况，我们希望的是一个socket连接在任意时刻都被一个线程处理，这是就用到了epoll的EPOLLNESHOT事件
对于注册了该事件的文件描述符，操作系统最多触发其上注册的一个可读可写或异常事件 且只触发一次，这样，当一个线程处理某个socket时，其他线程时不能操作该socket的，但是，注册了该事件的socket一旦被处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下次可读时，其EPOLLIN事件可以被触发，进而让其他线程有机会继续处理这个socket。
3. epoll_wait
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。
工作模式
epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：
-
LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。
-
ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。
ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
epoll 代码示例
server:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXEPOLL 100 /* 对于服务器来说，这个值可以很大的！ */
#define MAXLINE 1024
#define PORT 6000
#define MAXBACK 100
void ProcessData(int cli_sockfd);
//!> 设置非阻塞
int setnonblocking( int fd )
{
if( fcntl( fd, F_SETFL, fcntl( fd, F_GETFD, 0 )|O_NONBLOCK ) == -1 )
{
printf("Set blocking error : %d\n", errno);
return -1;
}
return 0;
}
int main( int argc, char ** argv )
{
int listen_fd;
int conn_fd;
int epoll_fd;
int nread;
int cur_fds; //!> 当前已经存在的数量
int wait_fds; //!> epoll_wait 的返回值
int i;
struct sockaddr_in servaddr;
struct sockaddr_in cliaddr;
struct epoll_event ev;
struct epoll_event evs[MAXEPOLL];
struct rlimit rlt; //!> 设置连接数所需
char buf[MAXLINE];
socklen_t len = sizeof( struct sockaddr_in );
//!> 设置每个进程允许打开的最大文件数
//!> 每个主机是不一样的哦，一般服务器应该很大吧！
//!>
rlt.rlim_max = rlt.rlim_cur = MAXEPOLL;
if( setrlimit( RLIMIT_NOFILE, &rlt ) == -1 )
{
printf("Setrlimit Error : %d\n", errno);
exit( EXIT_FAILURE );
}
//!> server 套接口
//!>
bzero( &servaddr, sizeof( servaddr ) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl( INADDR_ANY );
servaddr.sin_port = htons( PORT );
//!> 建立套接字
if( ( listen_fd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf("Socket Error %d...\n" , errno );
exit( EXIT_FAILURE );
}
//!> 设置非阻塞模式
//!>
if( setnonblocking( listen_fd ) == -1 )
{
printf("Setnonblocking Error : %d\n", errno);
exit( EXIT_FAILURE );
}
//!> 绑定
//!>
if( bind( listen_fd, ( struct sockaddr *)&servaddr, sizeof( struct sockaddr ) ) == -1 )
{
printf("Bind Error : %d\n", errno);
exit( EXIT_FAILURE );
}
//!> 监听
//!>
if( listen( listen_fd, MAXBACK ) == -1 )
{
printf("Listen Error : %d\n", errno);
exit( EXIT_FAILURE );
}
//!> 创建epoll
//!>
epoll_fd = epoll_create( MAXEPOLL ); //!> create
ev.events = EPOLLIN | EPOLLET; //!> accept Read!
ev.data.fd = listen_fd; //!> 将listen_fd 加入
if( epoll_ctl( epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev ) < 0 )
{
printf("Epoll Error : %d\n", errno);
exit( EXIT_FAILURE );
}
cur_fds = 1;
while( 1 )
{
if( ( wait_fds = epoll_wait( epoll_fd, evs, cur_fds, -1 ) ) == -1 )
{
printf( "Epoll Wait Error : %d\n", errno );
exit( EXIT_FAILURE );
}
for( i = 0; i < wait_fds; i++ )
{
if( evs[i].data.fd == listen_fd && cur_fds < MAXEPOLL )
//!> if是监听端口有事
{
if( ( conn_fd = accept( listen_fd, (struct sockaddr *)&cliaddr, &len ) ) == -1 )
{
printf("Accept Error : %d\n", errno);
exit( EXIT_FAILURE );
}
printf( "Server get from client !\n"/*, inet_ntoa(cliaddr.sin_addr), cliaddr.sin_port */);
ev.events = EPOLLIN | EPOLLET; // accept Read!
ev.data.fd = conn_fd; // 将conn_fd 加入
if( epoll_ctl( epoll_fd, EPOLL_CTL_ADD, conn_fd, &ev ) < 0 )
{
printf("Epoll Error : %d\n", errno);
exit( EXIT_FAILURE );
}
++cur_fds;
continue;
}
//!> 下面处理数据
//!>
ProcessData(evs[i].data.fd);
}
}
close( listen_fd );
return 0;
}
void ProcessData(int cli_sockfd)
{
//有客户端进行socket链接
//链接客户端数目自加
static int iClientNum=0;
int pid;
int iRecvLen;
unsigned char ucRecvBuf[1024];
iClientNum++;
printf("connect from client %d\n",iClientNum);
//为新的链接创建子进程
if(!(pid=fork()))
{
//子进程
while(1)
{
//接收客户端发来的信息，并进行回射
iRecvLen=recv(cli_sockfd, ucRecvBuf, 1000, 0);
if(iRecvLen<=0)
{
close(cli_sockfd);
exit(0);
}
else
{
ucRecvBuf[iRecvLen]='\0';
printf("Msg from Client %d :%s\n",iClientNum,ucRecvBuf);
write(cli_sockfd,ucRecvBuf,iRecvLen);
}
}
}
}
client:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXLINE 1024
#define SERV_PORT 6000
//!> 注意输入是由stdin，接受是由server发送过来
//!> 所以在client端也是需要select进行处理的
void send_and_recv( int connfd )
{
FILE * fp = stdin;
int lens;
char send[MAXLINE];
char recv[MAXLINE];
fd_set rset;
FD_ZERO( &rset );
int maxfd = ( fileno( fp ) > connfd ? fileno( fp ) : connfd + 1 );
//!> 输入和输出的最大值
int n;
while( 1 )
{
FD_SET( fileno( fp ), &rset );
FD_SET( connfd, &rset ); //!> 注意不要把rset看作是简单的一个变量
//!> 注意它其实是可以包含一组套接字的哦，
//!> 相当于是封装的数组！每次都要是新的哦！
if( select( maxfd, &rset, NULL, NULL, NULL ) == -1 )
{
printf("Client Select Error..\n");
exit(EXIT_FAILURE );
}
//!> if 连接口有信息
if( FD_ISSET( connfd, &rset ) ) //!> if 连接端口有信息
{
printf( "client get from server ...\n" );
memset( recv, 0, sizeof( recv ) );
n = read( connfd, recv, MAXLINE );
if( n == 0 )
{
printf("Recv ok...\n");
break;
}
else if( n == -1 )
{
printf("Recv error...\n");
break;
}
else
{
lens = strlen( recv );
recv[lens] = '\0';
//!> 写到stdout
write( STDOUT_FILENO, recv, MAXLINE );
printf("\n");
}
}
//!> if 有stdin输入
if( FD_ISSET( fileno( fp ), &rset ) ) //!> if 有输入
{
//!> printf("client stdin ...\n");
memset( send, 0, sizeof( send ) );
if( fgets( send, MAXLINE, fp ) == NULL )
{
printf("End...\n");
exit( EXIT_FAILURE );
}
else
{
//!>if( str )
lens = strlen( send );
send[lens-1] = '\0'; //!> 减一的原因是不要回车字符
//!> 经验值：这一步非常重要的哦！！！！！！！！
if( strcmp( send, "q" ) == 0 )
{
printf( "Bye..\n" );
return;
}
printf("Client send : %s\n", send);
write( connfd, send, strlen( send ) );
}
}
}
}
int main( int argc, char ** argv )
{
//!> char * SERV_IP = "10.30.97.188";
char buf[MAXLINE];
int connfd;
struct sockaddr_in servaddr;
if( argc != 2 )
{
printf("Input server ip !\n");
exit( EXIT_FAILURE );
}
//!> 建立套接字
if( ( connfd = socket( AF_INET, SOCK_STREAM, 0 ) ) == -1 )
{
printf("Socket Error...\n" , errno );
exit( EXIT_FAILURE );
}
//!> 套接字信息
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
//!> 链接server
if( connect( connfd, ( struct sockaddr * )&servaddr, sizeof( servaddr ) ) < 0 )
{
printf("Connect error..\n");
exit(EXIT_FAILURE);
}
//!>
//!> send and recv
send_and_recv( connfd );
//!>
close( connfd );
printf("Exit\n");
return 0;
}