我们目前的网络模型大都是epoll的，因为epoll模型会比select模型性能高很多， 尤其在大连接数的情况下，作为后台开发人员需要理解其中的原因。
select的特点：select 选择句柄的时候，是遍历所有句柄，也就是说句柄有事件响应时，select需要遍历所有句柄才能获取到哪些句柄有事件通知，因此效率是非常低。但是如果连接很少的情况下， select和epoll的LT触发模式相比， 性能上差别不大。
这里要多说一句，select支持的句柄数是有限制的， 同时只支持1024个，这个是句柄集合限制的，如果超过这个限制，很可能导致溢出，而且非常不容易发现问题， TAF就出现过这个问题， 调试了n天，才发现：）当然可以通过修改linux的socket内核调整这个参数。
epoll的特点：epoll对于句柄事件的选择不是遍历的，是事件响应的，就是句柄上事件来就马上选择出来，不需要遍历整个句柄链表，因此效率非常高，内核将句柄用红黑树保存的。
对于epoll而言还有ET和LT的区别，LT表示水平触发，ET表示边缘触发，两者在性能以及代码实现上差别也是非常大的。
LT：水平触发，效率会低于ET触发，尤其在大并发，大流量的情况下。但是LT对代码编写要求比较低，不容易出现问题。LT模式服务编写上的表现是：只要有数据没有被获取，内核就不断通知你，因此不用担心事件丢失的情况。
ET：边缘触发，效率非常高，在并发，大流量的情况下，会比LT少很多epoll的系统调用，因此效率高。但是对编程要求高，需要细致的处理每个请求，否则容易发生丢失事件的情况。
下面举一个列子来说明LT和ET的区别（都是非阻塞模式，阻塞就不说了，效率太低）：
采用LT模式下， 如果accept调用有返回就可以马上建立当前这个连接了，再epoll_wait等待下次通知，和select一样。
但是对于ET而言，如果accpet调用有返回，除了建立当前这个连接外，不能马上就epoll_wait还需要继续循环accpet，直到返回-1，且errno==EAGAIN，TAF里面的示例代码：
if(ev.events& EPOLLIN)
{
do
{
struct sockaddr_in stSockAddr;
socklen_t iSockAddrSize = sizeof(sockaddr_in);
TC_Socket cs;
cs.setOwner(false);
//接收连接
TC_Socket s;
s.init(fd, false, AF_INET);
int iRetCode = s.accept(cs, (struct sockaddr*) &stSockAddr, iSockAddrSize);
if (iRetCode > 0)
{
...建立连接
}
else
{
//直到发生EAGAIN才不继续accept
if(errno == EAGAIN)
{
break;
}
}
}while(true);
}
同样，recv/send等函数， 都需要到errno==EAGAIN
从本质上讲：与LT相比，ET模型是通过减少系统调用来达到提高并行效率的。
ET模型的逻辑：内核的读buffer有内核态主动变化时，内核会通知你， 无需再去mod。写事件是给用户使用的，最开始add之后，内核都不会通知你了，你可以强制写数据（直到EAGAIN或者实际字节数小于 需要写的字节数），当然你可以主动mod OUT，此时如果句柄可以写了（send buffer有空间），内核就通知你。
这里内核态主动的意思是：内核从网络接收了数据放入了读buffer（会通知用户IN事件，即用户可以recv数据）
并且这种通知只会通知一次，如果这次处理（recv）没有到刚才说的两种情况（EAGIN或者实际字节数小于 需要读写的字节数），则该事件会被丢弃，直到下次buffer发生变化。
与LT的差别就在这里体现，LT在这种情况下，事件不会丢弃，而是只要读buffer里面有数据可以让用户读，则不断的通知你。
另外对于ET而言，当然也不一定非send/recv到前面所述的结束条件才结束，用户可以自己随时控制，即用户可以在自己认为合适的时候去设置IN和OUT事件：
1 如果用户主动epoll_mod OUT事件，此时只要该句柄可以发送数据（发送buffer不满），则epoll
_wait就会响应（有时候采用该机制通知epoll_wai醒过来）。
2 如果用户主动epoll_mod IN事件，只要该句柄还有数据可以读，则epoll_wait会响应。
这种逻辑在普通的服务里面都不需要，可能在某些特殊的情况需要。 但是请注意，如果每次调用的时候都去epoll mod将显著降低效率，已经吃过几次亏了！
因此采用et写服务框架的时候，最简单的处理就是：
建立连接的时候epoll_add IN和OUT事件， 后面就不需要管了
每次read/write的时候，到两种情况下结束：
1 发生EAGAIN
2 read/write的实际字节数小于 需要读写的字节数
对于第二点需要注意两点：
A：如果是UDP服务，处理就不完全是这样，必须要recv到发生EAGAIN为止，否则就丢失事件了
因为UDP和TCP不同，是有边界的，每次接收一定是一个完整的UDP包，当然recv的buffer需要至少大于一个UDP包的大小
随便再说一下，一个UDP包到底应该多大？
对于internet，由于MTU的限制，UDP包的大小不要超过576个字节，否则容易被分包，对于公司的IDC环境，建议不要超过1472，否则也比较容易分包。
B 如果发送方发送完数据以后，就close连接，这个时候如果recv到数据是实际字节数小于读写字节数，根据开始所述就认为到EAGIN了从而直接返回，等待下一次事件，这样是有问题的，close事件丢失了！
因此如果依赖这种关闭逻辑的服务，必须接收数据到EAGIN为止，例如lb。
名词解释：man epoll之后，得到如下结果：
NAME
epoll - I/O event notification facility
SYNOPSIS
#include <sys/epoll.h>
DESCRIPTION
epoll is a variant of poll(2) that can be used either as Edge or Level
Triggered interface and scales well to large numbers of watched fds.
Three system calls are provided to set up and control an epoll set:
epoll_create(2), epoll_ctl(2), epoll_wait(2).
An epoll set is connected to a file descriptor created by epoll_cre-
ate(2). Interest for certain file descriptors is then registered via
epoll_ctl(2). Finally, the actual wait is started by epoll_wait(2).
其实，一切的解释都是多余的，按照我目前的了解，EPOLL模型似乎只有一种格式，所以大家只要参考我下面的代码，就能够对EPOLL有所了解了，代码的解释都已经在注释中：
while (TRUE)
{
int nfds = epoll_wait (m_epoll_fd, m_events, MAX_EVENTS, EPOLL_TIME_OUT);//等待EPOLL时间的发生，相当于监听，至于相关的端口，需要在初始化EPOLL的时候绑定。
if (nfds <= 0)
continue;
m_bOnTimeChecking = FALSE;
G_CurTime = time(NULL);
for (int i=0; i<nfds; i++)
{
try
{
if (m_events[i].data.fd == m_listen_http_fd)//如果新监测到一个HTTP用户连接到绑定的HTTP端口，建立新的连接。由于我们新采用了SOCKET连接，所以基本没用。
{
OnAcceptHttpEpoll ();
}
else if (m_events[i].data.fd == m_listen_sock_fd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
{
OnAcceptSockEpoll ();
}
else if (m_events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
{
OnReadEpoll (i);
}
OnWriteEpoll (i);//查看当前的活动连接是否有需要写出的数据。
}
catch (int)
{
PRINTF ("CATCH捕获错误/n");
continue;
}
}
m_bOnTimeChecking = TRUE;
OnTimer ();//进行一些定时的操作，主要就是删除一些短线用户等。
}
其实EPOLL的精华，按照我目前的理解，也就是上述的几段短短的代码，看来时代真的不同了，以前如何接受大量用户连接的问题，现在却被如此轻松的搞定，真是让人不得不感叹。
今天搞了一天的epoll，想做一个高并发的代理程序。刚开始真是郁闷,一直搞不通，网上也有几篇介绍epoll的文章。但都不深入，没有将一些注意的地方讲明。以至于走了很多弯路，现将自己的一些理解共享给大家,以少走弯路。
epoll用到的所有函数都是在头文件sys/epoll.h中声明，有什么地方不明白或函数忘记了可以去看一下。
epoll和select相比，最大不同在于:
1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。
2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。
1、epoll_create函数
函数声明：int epoll_create(int size)
该函数生成一个epoll专用的文件描述符。它其实是在内核申请一空间，用来存放你想关注的socket fd上是否发生以及发生了什么事件。size就是你在这个epoll fd上能关注的最大socket fd数。随你定好了。只要你有空间。可参见上面与select之不同2.
22、epoll_ctl函数
函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
该函数用于控制某个epoll文件描述符上的事件，可以注册事件，修改事件，删除事件。
参数：
epfd：由 epoll_create 生成的epoll专用的文件描述符；
op：要进行的操作例如注册事件，可能的取值EPOLL_CTL_ADD 注册、EPOLL_CTL_MOD 修 改、EPOLL_CTL_DEL 删除
fd：关联的文件描述符；
event：指向epoll_event的指针；
如果调用成功返回0,不成功返回-1
用到的数据结构
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 */
};
如：
struct epoll_event ev;
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
常用的事件类型:
EPOLLIN ：表示对应的文件描述符可以读；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET：表示对应的文件描述符有事件发生；
3、epoll_wait函数
函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
该函数用于轮询I/O事件的发生；
参数：
epfd:由epoll_create 生成的epoll专用的文件描述符；
epoll_event:用于回传代处理事件的数组；
maxevents:每次能处理的事件数；
timeout:等待I/O事件发生的超时值(单位我也不太清楚)；-1相当于阻塞，0相当于非阻塞。一般用-1即可
返回发生事件数。
- #include <stdio.h>
- #include <stdlib.h>
- #include <errno.h>
- #include <string.h>
- #include <sys/types.h>
- #include <netinet/in.h>
- #include <sys/socket.h>
- #include <sys/wait.h>
- #include <unistd.h>
- #include <arpa/inet.h>
- #include <openssl/ssl.h>
- #include <openssl/err.h>
- #include <fcntl.h>
- #include <sys/epoll.h>
- #include <sys/time.h>
- #include <sys/resource.h>
- #define MAXBUF 1024
- #define MAXEPOLLSIZE 10000
- /*
- setnonblocking - 设置句柄为非阻塞方式
- */
- int setnonblocking(int sockfd)
- {
- if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)
- {
- return -1;
- }
- return 0;
- }
- /*
- handle_message - 处理每个 socket 上的消息收发
- */
- int handle_message(int new_fd)
- {
- char buf[MAXBUF + 1];
- int len;
- /* 开始处理每个新连接上的数据收发 */
- bzero(buf, MAXBUF + 1);
- /* 接收客户端的消息 */
- len = recv(new_fd, buf, MAXBUF, 0);
- if (len > 0)
- {
- printf
- ("%d接收消息成功:'%s'，共%d个字节的数据/n",
- new_fd, buf, len);
- }
- else
- {
- if (len < 0)
- printf
- ("消息接收失败！错误代码是%d，错误信息是'%s'/n",
- errno, strerror(errno));
- close(new_fd);
- return -1;
- }
- /* 处理每个新连接上的数据收发结束 */
- return len;
- }
- /************关于本文档********************************************
- *filename: epoll-server.c
- *purpose: 演示epoll处理海量socket连接的方法
- *wrote by: zhoulifa(<a href="mailto:zhoulifa@163.com">zhoulifa@163.com</a>) 周立发(<a href="http://zhoulifa.bokee.com">http://zhoulifa.bokee.com</a>)
- Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言
- *date time:2007-01-31 21:00
- *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途
- * 但请遵循GPL
- *Thanks to:Google
- *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力
- * 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！
- *********************************************************************/
- int main(int argc, char **argv)
- {
- int listener, new_fd, kdpfd, nfds, n, ret, curfds;
- socklen_t len;
- struct sockaddr_in my_addr, their_addr;
- unsigned int myport, lisnum;
- struct epoll_event ev;
- struct epoll_event events[MAXEPOLLSIZE];
- struct rlimit rt;
- myport = 5000;
- lisnum = 2;
- /* 设置每个进程允许打开的最大文件数 */
- rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;
- if (setrlimit(RLIMIT_NOFILE, &rt) == -1)
- {
- perror("setrlimit");
- exit(1);
- }
- else
- {
- printf("设置系统资源参数成功！/n");
- }
- /* 开启 socket 监听 */
- if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)
- {
- perror("socket");
- exit(1);
- }
- else
- {
- printf("socket 创建成功！/n");
- }
- setnonblocking(listener);
- bzero(&my_addr, sizeof(my_addr));
- my_addr.sin_family = PF_INET;
- my_addr.sin_port = htons(myport);
- my_addr.sin_addr.s_addr = INADDR_ANY;
- if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)
- {
- perror("bind");
- exit(1);
- }
- else
- {
- printf("IP 地址和端口绑定成功/n");
- }
- if (listen(listener, lisnum) == -1)
- {
- perror("listen");
- exit(1);
- }
- else
- {
- printf("开启服务成功！/n");
- }
- /* 创建 epoll 句柄，把监听 socket 加入到 epoll 集合里 */
- kdpfd = epoll_create(MAXEPOLLSIZE);
- len = sizeof(struct sockaddr_in);
- ev.events = EPOLLIN | EPOLLET;
- ev.data.fd = listener;
- if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)
- {
- fprintf(stderr, "epoll set insertion error: fd=%d/n", listener);
- return -1;
- }
- else
- {
- printf("监听 socket 加入 epoll 成功！/n");
- }
- curfds = 1;
- while (1)
- {
- /* 等待有事件发生 */
- nfds = epoll_wait(kdpfd, events, curfds, -1);
- if (nfds == -1)
- {
- perror("epoll_wait");
- break;
- }
- /* 处理所有事件 */
- for (n = 0; n < nfds; ++n)
- {
- if (events[n].data.fd == listener)
- {
- new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);
- if (new_fd < 0)
- {
- perror("accept");
- continue;
- }
- else
- {
- printf("有连接来自于： %d:%d， 分配的 socket 为:%d/n",
- inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
- }
- setnonblocking(new_fd);
- ev.events = EPOLLIN | EPOLLET;
- ev.data.fd = new_fd;
- if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)
- {
- fprintf(stderr, "把 socket '%d' 加入 epoll 失败！%s/n",
- new_fd, strerror(errno));
- return -1;
- }
- curfds++;
- }
- else
- {
- ret = handle_message(events[n].data.fd);
- if (ret < 1 && errno != 11)
- {
- epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);
- curfds--;
- }
- }
- }
- }
- close(listener);
- return 0;
- }
epoll_wait运行的原理是 等侍注册在epfd上的socket fd的事件的发生，如果发生则将发生的sokct fd和事件类型放入到events数组中。 并且将注册在epfd上的socket fd的事件类型给清空，所以如果下一个循环你还要关注这个socket fd的话，则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。这时不用EPOLL_CTL_ADD,因为socket fd并未清空，只是事件类型清空。这一步非常重要。
3090
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
