1、epoll使用模型
示例程序1
View Code
for(;;)
{
nfds = epoll_wait(epfd, events, 20, 500);
for(i =0; i < nfds; ++i)
{
if(events[i].data.fd == listenfd) //监测到有新的连接
{
connfd = accept(listenfd, (sockaddr *)&clientaddr, &clilen); //accept这个连接
ev.data.fd = connfd;
ev.events = EPOLLIN | EPOLLET;
//这里的参数EPOLLIN | EPOLLET并没有设置对写socket的监听，如果有写操作的话，这
//个时候epoll是不会返回事件的，如果要对写操作也监听的话，应该是EPOLLIN | EPOLLOUT | EPOLLET
//实际上，并不需要这么做，因为，我们往往希望读完写，写完读，而不是一直读，或一直写。
//所以，本模型中的设置就可以工作的很好。
epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev); //将新的fd添加到epoll的监听队列中
//每一步设置都应当进行判断
}
elseif( events[i].events & EPOLLIN ) //已经连接的用户,并且接收到数据,读socket
{
n = read(sockfd, line, MAXLINE)) <0//读,并判断
ev.data.ptr = md; //md为自定义类型,添加数据
ev.events = EPOLLOUT | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);//修改标识符,等待下一个循环时发送数据,异步处理的精髓
}
elseif(events[i].events & EPOLLOUT) //有数据待发送,写socket
{
struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;//取数据
sockfd = md->fd;
send(sockfd, md->ptr, strlen((char*)md->ptr), 0 ); //发送数据
ev.data.fd = sockfd;
ev.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);//修改标识符,等待下一个循环时接收数据
}
else
{
//其他的处理
}
}
}
2、示例使用【1】
示例程序2
View Code
#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
usingnamespace std;
#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000
void setnonblocking(int sock)
{
int opts;
opts = fcntl(sock,F_GETFL);
if(opts <0)
{
perror("fcntl(sock,GETFL)");
exit(1);
}
opts = opts|O_NONBLOCK;
if(fcntl(sock,F_SETFL,opts)<0)
{
perror("fcntl(sock,SETFL,opts)");
exit(1);
}
}
int main(int argc, char* argv[])
{
int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
if (2== argc)
{
if( (portnumber = atoi(argv[1])) <0 )
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
return1;
}
}
else
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv[0]);
return1;
}
//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
struct epoll_event ev, events[20];
//生成用于处理accept的epoll专用的文件描述符
epfd = epoll_create(256);
struct sockaddr_in clientaddr;
struct sockaddr_in serveraddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
//把socket设置为非阻塞方式
//setnonblocking(listenfd);
//设置与要处理的事件相关的文件描述符
ev.data.fd = listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN | EPOLLET;
//ev.events = EPOLLIN;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
bzero(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
char*local_addr="127.0.0.1";
inet_aton(local_addr,&(serveraddr.sin_addr));//htons(portnumber);
serveraddr.sin_port=htons(portnumber);
bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
listen(listenfd, LISTENQ);
maxi =0;
for (;;)
{
//等待epoll事件的发生
nfds = epoll_wait(epfd, events, 20, 500);
//处理所发生的所有事件
for(i =0; i < nfds; ++i)
{
if(events[i].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);
cout <<"accapt a connection from "<< str << endl;
//设置用于读操作的文件描述符
ev.data.fd = connfd;
//设置用于注测的读操作事件
ev.events = EPOLLIN | EPOLLET;
//ev.events = EPOLLIN;
//注册ev
epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
}
elseif(events[i].events & EPOLLIN)
{
cout <<"EPOLLIN"<< endl;
if ((sockfd = events[i].data.fd) <0)
continue;
if ((n = read(sockfd, line, MAXLINE)) <0)
{
if (errno == ECONNRESET)
{
close(sockfd);
events[i].data.fd =-1;
}
else
{
std::cout<<"readline error"<<std::endl;
}
}
elseif (n ==0)
{
close(sockfd);
events[i].data.fd =-1;
}
line[n] ='\0';
cout <<"read "<< line << endl;
//设置用于写操作的文件描述符
ev.data.fd=sockfd;
//设置用于注测的写操作事件
ev.events=EPOLLOUT|EPOLLET;
//修改sockfd上要处理的事件为EPOLLOUT
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
}
elseif(events[i].events & EPOLLOUT) //如果有数据发送
{
sockfd = events[i].data.fd;
write(sockfd, line, n);
//设置用于读操作的文件描述符
ev.data.fd = sockfd;
//设置用于注测的读操作事件
ev.events = EPOLLIN | EPOLLET;
//修改sockfd上要处理的事件为EPOLIN
epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
}
}
}
return0;
}
3、socket有个listen队列，用来存放应用程序没有accept的连接。同样，epoll也有个wait queue。有一个关于epoll的数据结构常驻内核。
4、处理过程
1)select/poll
step1:准备fd;
step2:select
step2:process
step4:go to step1
2)epoll
step1:epoll_create
step2:epoll_wait
step3:process
step4:go to step2
5、非阻塞的模式，当errno为EAGAIN时，表示当前缓冲区已无数据可读。当写缓冲已满，此时send()返回-1，且errno为EAGAIN，这种情况，我们封装send时要处理。
设计成ET模式下的读模型
View Code
while(rs)
{
buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
if(buflen <0)
{
// 由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可读
// 在这里就当作是该次事件已处理处.
if(errno == EAGAIN)
break;
else
return;
}
elseif(buflen ==0)
{
// 这里表示对端的socket已正常关闭.
}
//读数据的时候需要考虑的是当recv()返回的大小如果等于请求的大小，那么很有
//可能是缓冲区还有数据未读完，意味着该次事件还没有处理完，还需要再次读取
if(buflen ==sizeof(buf)
rs =1; // 需要再次读取
else
rs =0;
}
设计成ET模式下的写模型
View Code
ssize_t socket_send(int sockfd, constchar* buffer, size_t buflen)
{
ssize_t tmp;
size_t total = buflen;
constchar*p = buffer;
while(1)
{
tmp = send(sockfd, p, total, 0);
if(tmp <0)
{
// 当send收到信号时,可以继续写,但这里返回-1.
if(errno == EINTR)
return-1;
// 当socket是非阻塞时,如返回此错误,表示写缓冲队列已满,
// 在这里做延时后再重试.
if(errno == EAGAIN)
{
usleep(1000);
continue;
}
return-1;
}
if((size_t)tmp == total)
return buflen;
total -= tmp;
p += tmp;
}
return tmp;
}
6、UDP没有流的概念，而是数据包；也就是说读一次，缓存足够下，如果成功，则肯定读了一个包；否则失败。
7、ET是状态的；也就是说，只在状态发生改变时，他才会进行通知；比如缓存由不可读状态变成可读状态，则进行一次通知；所以，一旦wait成功，则要一直读，读到不能读，状态发生变化为止。而LT是基于事件的，也就是每发生一个事件，就会通知一次，比如有新的数据包到达，这就是一个事件，就会有一次通知。
附：其它关联词汇
1、AIO：Asynchronous Input/Output异步输入/输出是任何特殊输入/输出流（同步和异步输入/输出）两个基本操作模式之一。在异步模式中，自然的输入/输出事务不必须和一个程序的输入/输出状态同步或互锁。
参考：
【1】 epoll的相关概念和使用
http://baike.baidu.com/view/1385104.htm
http://www.cnblogs.com/OnlyXP/archive/2007/08/10/851222.html
文章中举了一个实例：
http://blogold.chinaunix.net/u/16292/showart_1844376.html
http://www.vimer.cn/2009/11/epoll%E4%BD%BF%E7%94%A8%E5%AE%9E%E4%BE%8B%E8%AF%B4%E6%98%8E.html