一、epoll 系列函数简介
#include <sys/epoll.h> int epoll_create(int size); int epoll_create1(int flags); int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
* epoll_create(2) creates an epoll instance and returns a file descriptor referring to that instance. (The more recent epoll_create1(2) extends the functionality of epoll_create(2).) * Interest in particular file descriptors is then registered via epoll_ctl(2). The set of file descriptors currently registered on an epoll instance is sometimes called an epoll set. * epoll_wait(2) waits for I/O events, blocking the calling thread if no events are currently available.
1、epoll_create1 产生一个epoll 实例,返回的是实例的句柄。flag 可以设置为0 或者EPOLL_CLOEXEC,为0时函数表现与epoll_create一致,EPOLL_CLOEXEC标志与open 时的O_CLOEXEC 标志类似,即进程被替换时会关闭打开的文件描述符。
2、epoll_ctl :
(1)epfd:epoll 实例句柄;
(2)op:对文件描述符fd 的操作,主要有EPOLL_CTL_ADD、 EPOLL_CTL_DEL等;
(3)fd:需要操作的目标文件描述符;
(4)event:结构体指针
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 */ };
events 参数主要有EPOLLIN、EPOLLOUT、EPOLLET、EPOLLLT等;一般data 共同体我们设置其成员fd即可,也就是epoll_ctl 函数的第三个参数。
3、epoll_wait:
(1)epfd:epoll 实例句柄;
(2)events:结构体指针
(3)maxevents:事件的最大个数
(4)timeout:超时时间,设为-1表示永不超时
下面我们使用c++ 来实现一个服务器端程序:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | #include <unistd.h>#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <arpa/inet.h>#include <signal.h>#include <fcntl.h>#include <sys/wait.h>#include <sys/epoll.h>#include <stdlib.h>#include <stdio.h>#include <errno.h>#include <string.h>#include <vector>#include <algorithm>#include "read_write.h"#include "sysutil.h"typedef std::vector<struct epoll_event> EventList;/* 相比于select与poll,epoll最大的好处是不会随着关心的fd数目的增多而降低效率 */int main(void) { int count = 0; int listenfd; if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) ERR_EXIT("socket"); struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(5188); servaddr.sin_addr.s_addr = htonl(INADDR_ANY); int on = 1; if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) ERR_EXIT("setsockopt"); if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) ERR_EXIT("bind"); if (listen(listenfd, SOMAXCONN) < 0) ERR_EXIT("listen"); std::vector<int> clients; int epollfd; epollfd = epoll_create1(EPOLL_CLOEXEC); //epoll实例句柄 struct epoll_event event; event.data.fd = listenfd; event.events = EPOLLIN | EPOLLET; //边沿触发 epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event); EventList events(16); struct sockaddr_in peeraddr; socklen_t peerlen; int conn; int i; int nready; while (1) { nready = epoll_wait(epollfd, &*events.begin(), static_cast<int>(events.size()), -1); if (nready == -1) { if (errno == EINTR) continue; ERR_EXIT("epoll_wait"); } if (nready == 0) continue; if ((size_t)nready == events.size()) events.resize(events.size() * 2); for (i = 0; i < nready; i++) { if (events[i].data.fd == listenfd) { peerlen = sizeof(peeraddr); conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen); if (conn == -1) ERR_EXIT("accept"); printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); printf("count = %d\n", ++count); clients.push_back(conn); activate_nonblock(conn); event.data.fd = conn; event.events = EPOLLIN | EPOLLET; epoll_ctl(epollfd, EPOLL_CTL_ADD, conn, &event); } else if (events[i].events & EPOLLIN) { conn = events[i].data.fd; if (conn < 0) continue; char recvbuf[1024] = { 0}; int ret = readline(conn, recvbuf, 1024); if (ret == -1) ERR_EXIT("readline"); if (ret == 0) { printf("client close\n"); close(conn); event = events[i]; epoll_ctl(epollfd, EPOLL_CTL_DEL, conn, &event); clients.erase(std::remove(clients.begin(), clients.end(), conn), clients.end()); } fputs(recvbuf, stdout); writen(conn, recvbuf, strlen(recvbuf)); } } } return 0; } |
在程序的最开始定义一个新类型EventList,内部装着struct epoll_event 结构体的容器。
接下面的socket,bind,listen 都跟以前说的一样,不述。接着使用epoll_create1 创建一个epoll 实例,再来看下面四行代码:
struct epoll_event event; event.data.fd = listenfd; event.events = EPOLLIN | EPOLLET; //边沿触发 epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);
根据前面的函数分析,这四句意思就是将监听套接字listenfd 加入关心的套接字序列。
在epoll_wait 函数中的第二个参数,其实events.begin() 是个迭代器,但其具体实现也是struct epoll_event* 类型,虽然 &*events.begin() 得到的也是struct epoll_event* ,但不能直接使用events.begin() 做参数,因为类型不匹配,编译会出错。
EventList events(16); 即初始化容器的大小为16,当返回的事件个数nready 已经等于16时,需要增大容器的大小,使用events.resize 函数即可,容器可以动态增大,这也是我们使用c++实现的其中一个原因。
当监听套接字有可读事件,accept 返回的conn也需要使用epoll_ctl 函数将其加入关心的套接字队列。
还需要调用 (conn); 将conn 设置为非阻塞,man 7 epoll 里有这样一句话:
An application that employs the EPOLLET flag should use nonblocking file descriptors to avoid having a blocking read or write starve a task that is handling multiple file descriptors.
当下次循环回来某个已连接套接字有可读事件,则读取数据,若read 返回0表示对方关闭,需要使用epoll_ctl 函数将conn 从队列中清除,我们使用 std::vector<int> clients; 来保存每次accept 返回的conn,所以现在也需要将其擦除掉,调用clients.erase() 函数。
我们可以使用前面写的 客户端程序测试一下,先运行服务器程序,再运行客户端,输出如下:
simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./echoser_epoll
................................
count = 1015 ip=127.0.0.1 port=60492 count = 1016 ip=127.0.0.1 port=60493 count = 1017 ip=127.0.0.1 port=60494 count = 1018 ip=127.0.0.1 port=60495 count = 1019 accept: Too many open files
simba@ubuntu:~/Documents/code/linux_programming/UNP/socket$ ./conntest
.........................................................
count = 1015 ip=127.0.0.1 port=60492 count = 1016 ip=127.0.0.1 port=60493 count = 1017 ip=127.0.0.1 port=60494 count = 1018 ip=127.0.0.1 port=60495 count = 1019 connect: Connection reset by peer
为什么服务器端的count 只有1019呢,因为除去012,一个监听套接字还有一个epoll 实例句柄,所以1024 - 5 = 1019。
为什么客户端的错误提示跟的不一样呢?这正说明epoll 处理效率比poll和select 都高,因为处理得快,来一个连接就accept一个,当服务器端accept 完第1019个连接,再次accept 时会因为文件描述符总数超出限制,打印错误提示,而此时客户端虽然已经创建了第1020个sock,但在connect 过程中发现对等方已经退出了,故打印错误提示,连接被对等方重置。如果服务器端处理得慢的话,那么客户端会connect 成功1021个连接,然后在创建第1022个sock 的时候出错,打印错误提示:socket: Too many open files,当然因为文件描述符的限制,服务器端也只能从已完成连接队列中accept 成功1019个连接。
二、epoll与select、poll区别
1、相比于select与poll,epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。内核中的select与poll的实现是采用轮询来处理的,轮询的fd数目越多,自然耗时越多。
2、epoll的实现是基于回调的,如果fd有期望的事件发生就通过回调函数将其加入epoll就绪队列中,也就是说它只关心“活跃”的fd,与fd数目无关。
3、epoll不仅会告诉应用程序有I/0 事件到来,还会告诉应用程序相关的信息,这些信息是应用程序填充的,因此根据这些信息应用程序就能直接定位到事件,而不必遍历整个fd集合。
4、当已连接的套接字数量不太大,并且这些套接字都非常活跃,那么对于epoll 来说一直在调用callback 函数(epoll 内部的实现更复杂,更复杂的代码逻辑),可能性能没有poll 和 select 好,因为一次性遍历对活跃的文件描述符处理,在连接数量不大的情况下,性能更好,但在处理大量连接的情况时,epoll 明显占优。
三、epoll 的EPOLLLT (电平触发,默认)和 EPOLLET(边沿触发)模式的区别
1、EPOLLLT:完全靠kernel epoll驱动,应用程序只需要处理从epoll_wait返回的fds,这些fds我们认为它们处于就绪状态。此时epoll可以认为是更快速的poll。
2、EPOLLET:此模式下,系统仅仅通知应用程序哪些fds变成了就绪状态,一旦fd变成就绪状态,epoll将不再关注这个fd的任何状态信息,(从epoll队列移除)直到应用程序通过读写操作(非阻塞)触发EAGAIN状态,epoll认为这个fd又变为空闲状态,那么epoll又重新关注这个fd的状态变化(重新加入epoll队列)。随着epoll_wait的返回,队列中的fds是在减少的,所以在大并发的系统中,EPOLLET更有优势,但是对程序员的要求也更高,因为有可能会出现数据读取不完整的问题,举例如下:
假设现在对方发送了2k的数据,而我们先读取了1k,然后这时调用了epoll_wait,如果是边沿触发,那么这个fd变成就绪状态就会从epoll 队列移除,很可能epoll_wait 会一直阻塞,忽略尚未读取的1k数据,与此同时对方还在等待着我们发送一个回复ack,表示已经接收到数据;如果是电平触发,那么epoll_wait 还会检测到可读事件而返回,我们可以继续读取剩下的1k 数据。
注:上述使用 epoll ET 的例子只是个示例,更规范的用法可以参考。
参考:
《Linux C 编程一站式学习》
《TCP/IP详解 卷一》
《UNP》
select, poll和epoll的区别
#include <sys/time.h>#include <sys/types.h>#include <unistd.h>int select (int n,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,struct timeval *timeout);FD_CLR(int fd, fd_set *set);FD_ISSET(int fd, fd_set *set);FD_SET(int fd, fd_set *set);FD_ZERO(fd_set *set); |
#include <sys/time.h>struct timeval { long tv_sec; /* seconds */long tv_usec; /* 10E-6 second */}; |
#include <sys/poll.h>int poll (struct pollfd *fds, unsigned int nfds, int timeout); |
#include <sys/poll.h>struct pollfd { int fd; /* file descriptor */short events; /* requested events to watch */short revents; /* returned events witnessed */}; |
epoll学习,epoll与select,pool区别
在linux网络编程中,很长的时间都是用select来做事件触发.在linux新内核中,有了一种替换它的机制,就是epoll.
相比于select,epoll最大的好处在于它不会随着监听fd数目的增长而降低效率.因为在内核中的select实现中,它是采用轮询来处理的,轮询的fd数据数据越多,自然耗时就越多.
epoll的接口三个函数
1) int epoll_create(int size);
创建一个epoll句柄,size用来告诉内核这个监听的数据一共有多大.
需要注意的是,当创建好epoll句柄后,它会占用一个fd值,在使用完epoll后,必须调用close关闭,否则可能导致fd被耗尽.
2) int epoll_ctl(int epfd,int op,int fd,struct epoll_event *event);
epoll注册函数,第一个参数是epoll_create()的返回值.
第二个参数表示动作,用三个宏来表示
EPOLL_CTL_ADD:注册新的fd到epfd中
EPOLL_CTL_MOD: 修改已经注册的fd的监听事件
EPOLL_CTL_DEL:从epfd中删除一个fd
第三个参数是需要监听的fd
第四个参数是告诉内核需要监听什么事.
struct_event结构如下:
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 */ };
events可以是以下几个宏的集合:
EPOLLIN:表示对应的文件描述符可读(包括对端SOCKET正常关闭)
EPOLLOUT:表示对应的文件描述符可以写
EPOLLPRI:表示对应的文件描述符有紧急的数据可读
EPOLLERR表示对应的文件描述符发生错误
EPOLLHUP:表示对应的文件描述符被挂断
EPOLLET:将EPOLL设为边缘触发模式(Edge Triggered).这是相对于水平触发(Level Triggered)来说的
EPOLLONSHOT:只监听一次,当监听玩这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到WPOLL队列里
3) int epoll_wait(int epfd,struct epoll_event *events,int maxevents,int timeout);
参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大,这个maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒),0会立即返回,-1将不确定,也有说法是永久阻塞.该函数返回需要处理的事件数目,如返回0表示已超时.
关于ET.LT两种工作模式
ET模式仅当状态发送变化的时候才获得通知,这里所谓的状态的变化并不包括缓冲区中还有未处理的数据,也就是说.如果要采用ET模式,需要一直read/write直到出错为止.很多人反映为什么采用ET模式只接收了一部分数据就再也得不到通知了,大多是因为这样.
而LT模式就是只要有数据没有处理就会一直通知下去.
epoll模型
首先通过create_epoll(int maxfds)来创建一个epoll的句柄,其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄,之后的所有操作将通过这个句柄来进行操作。在用完之后,记得用close()来关闭这个创建出来的epoll句柄。
之后在你的网络主循环里面,每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口,看哪一个可以读,哪一个可以写了。基本的语法为: nfds = epoll_wait(kdpfd, events, maxevents, -1); 其中kdpfd为用epoll_create创建之后的句柄,events是一个epoll_event*的指针,当epoll_wait这个函数操作成功之后,epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时,为0的时候表示马上返回,为-1的时候表示一直等下去,直到有事件范围,为任意正整数的时候表示等这么长的时间,如果一直没有事件,则范围。一般如果网络主循环是单独的线程的话,可以用-1来等,这样可以保证一些效率,如果是和主逻辑在同一个线程的话,则可以用0来保证主循环的效率。 epoll_wait范围之后应该是一个循环,遍利所有的事件。
#include#include #include #include #include #include #include #include #include using namespace std; int main(int argc,char *argv[]) { int maxi,listenfd,connfd,sockfd,epfd,nfds; ssize_t n; char line[100]; listenfd = socket(AF_INET,SOCK_STREAM,0); //声明epoll_event结构体变量,ev用于注册事件,数组用于回传要处理的事件 struct epoll_event ev,events[20]; epfd = epoll_create(256); ev.date.fd = listenfd; ev.events = EPOLLIN|EPOLLET; epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev); //注册epoll事件 struct sockaddr_in serveraddr; bzero(&serveraddr,sizeof(serveraddr)); char *local_addr = "127.0.0.1"; inet_aton(local_addr,&(serveraddr.sin_addr)); serveraddr.sin_port=htons(8888); bind(listenfd,(sockaddr*)&serveraddr,sizeof(serveraddr)); listen(listenfd,LISTENQ); maxi=0; for(;;) { //等待epoll事件发生 nfds = epoll_wait(epfd,events,20,500); //处理发生的所有事件 for(int i = 0;i
epoll和select,poll区别
1. 支持一个进程打开大数目的socket描述符(FD)
select最不能忍受的是一个进程所打开的FD是有一定限制的,由FD_SETSIZE设置,默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核,不过资料也同时指出这样会带来网络效率的下降
2. IO效率不随FD数目增加而线性下降
传统的select/poll另外一个致命弱点就是当你拥有一个很大的socket集合,不过由于网络延时,任一时间只有部分socket是“活跃”的,但是select/poll每次调用都会线性扫描全部的集合,导致效率呈线性下降。但是epoll不存在这个问题,它只会对“活跃”的socket进行操作——这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。
epoll采用基于事件的就绪通知方式。在select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个文件描述符,当进程调用epoll_wait()时便得到通知。
3. 使用mmap加速内核与用户空间的消息传递
无论是select,poll还是epoll都需要内核把FD消息通知给用户空间,如何避免不必要的内存拷贝就很重要,在这点上,epoll是通过内核于用户空间mmap同一块内存实现的
4. 内核微调
这一点其实不算epoll的优点了,而是整个Linux平台的优点.
-
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
select、poll、epoll使用小结
Linux上可以使用不同的I/O模型,我们可以通过下图了解常用的I/O模型:同步和异步模型,以及阻塞和非阻塞模型,本文主要分析其中的异步阻塞模型。
一、select使用
这个模型中配置的是非阻塞I/O,然后使用阻塞select系统调用来确定一个I/O描述符何时有操作。使用select调用可以为多个描述符提供通知,对于每个提示符,我们可以请求描述符的可写,可读以及是否发生错误。异步阻塞I/O的系统流程如下图所示:
使用select常用的几个函数如下:
- FD_ZERO(int fd, fd_set* fds)
- FD_SET(int fd, fd_set* fds)
- FD_ISSET(int fd, fd_set* fds)
- FD_CLR(int fd, fd_set* fds)
- int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
fd_set类型可以简单的理解为按bit位标记句柄的队列。具体的置位、验证可以使用FD_SET,FD_ISSET等宏实现。在select函数中,readfds、writefds和exceptfds同时作为输入参数和输出参数,如果readfds标记了一个位置,则,select将检测到该标记位可读。timeout为设置的超时时间。
下面我们来看如何使用select:
- SOCKADDR_IN addrSrv;
- int reuse = 1;
- SOCKET sockSrv,connsock;
- SOCKADDR_IN addrClient;
- pool pool;
- int len=sizeof(SOCKADDR);
- /*创建TCP*/
- sockSrv=socket(AF_INET,SOCK_STREAM,0);
- /*地址、端口的绑定*/
- addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
- addrSrv.sin_family=AF_INET;
- addrSrv.sin_port=htons(port);
- if(bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR))<0)
- {
- fprintf(stderr,"Failed to bind");
- return ;
- }
- if(listen(sockSrv,5)<0)
- {
- fprintf(stderr,"Failed to listen socket");
- return ;
- }
- setsockopt(sockSrv,SOL_SOCKET,SO_REUSEADDR,(const char*)&reuse,sizeof(reuse));
- init_pool(sockSrv,&pool);
- while(1)
- {
- /*通过selete设置为异步模式*/
- pool.ready_set=pool.read_set;
- pool.nready=select(pool.maxfd+1,&pool.ready_set,NULL,NULL,NULL);
- if(FD_ISSET(sockSrv,&pool.ready_set))
- {
- connsock=accept(sockSrv,(SOCKADDR *)&addrClient,&len);
- //loadDeal()/*连接处理*/
- //printf("test\n");
- add_client(connsock,&pool);//添加到连接池
- }
- /*检查是否有事件发生*/
- check_client(&pool);
- }
上面是一个服务器代码的关键部分,设置为异步的模式,然后接受到连接将其添加到连接池中。监听描述符上使用select,接受客户端的连接请求,在check_client函数中,遍历连接池中的描述符,检查是否有事件发生。
二、poll使用
poll函数类似于select,但是其调用形式不同。poll不是为每个条件构造一个描述符集,而是构造一个pollfd结构体数组,每个数组元素指定一个描述符标号及其所关心的条件。定义如下:
- #include <sys/poll.h>
- int poll (struct pollfd *fds, unsigned int nfds, int timeout);
- struct pollfd {
- int fd; /* file descriptor */
- short events; /* requested events to watch */
- short revents; /* returned events witnessed */
- };
每个结构体的events域是由用户来设置,告诉内核我们关注的是什么,而revents域是返回时内核设置的,以说明对该描述符发生了什么事件。这点与select不同,select修改其参数以指示哪一个描述符准备好了。在《unix环境高级编程》中有一张events取值的表,如下:
POLLIN :可读除高优级外的数据,不阻塞
POLLRDNORM:可读普通数据,不阻塞
POLLRDBAND:可读O优先数据,不阻塞
POLLPRI:可读高优先数据,不阻塞
POLLOUT :可写普数据,不阻塞
POLLWRNORM:与POLLOUT相同
POLLWRBAND:写非0优先数据,不阻塞
其次revents还有下面取值
POLLERR :已出错
POLLHUP:已挂起,当以描述符被挂起后,就不能再写向该描述符,但是仍可以从该描述符读取到数据。
POLLNVAL:此描述符并不引用一打开文件
对poll函数,nfds表示fds中的元素数,timeout为超时设置,单位为毫秒若为0,表示不等待,为-1表示描述符中一个已经准备好或捕捉到一个信号返回,大于0表示描述符准备好,或超时返回。函数返回值返回值若为0,表示没有事件发生,-1表示错误,并设置errno,大于0表示有几个描述符有事件。
poll的使用和select基本类似。在此不再介绍。poll相对于是select的优势是监听的描述符数量没有限制。
三、epoll学习
epoll有两种模式,Edge Triggered(简称ET) 和 Level Triggered(简称LT).在采用这两种模式时要注意的是,如果采用ET模式,那么仅当状态发生变化时才会通知,而采用LT模式类似于原来的select/poll操作,只要还有没有处理的事件就会一直通知.
1)epoll数据结构介绍:
- 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 */
- };
常见的事件如下:
EPOLLIN:表示对描述符的可以读
EPOLLOUT:表示对描述符的可以写
EPOLLPRI:表示对描述符的有紧急数据可以读
EPOLLERR:发生错误
EPOLLHUP:挂起
EPOLLET:边缘触发
EPOLLONESHOT:一次性使用,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里
2)函数介绍
epoll的三个函数
- int epoll_creae(int size);
功能:该函数生成一个epoll专用的文件描述符
参数:size为epoll上能关注的最大描述符数
- 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_DEL删除
fd:关联的文件描述符
evnet告诉内核要监听什么事件
- int epoll_wait(int epfd,struct epoll_event*events,int maxevents,int timeout);
功能:该函数等待i/o事件的发生。
参数:epfd要检测的句柄
events:用于回传待处理时间的数组
maxevents:告诉内核这个events有多大,不能超过之前的size
timeout:为超时时间
使用方法参考:
epoll支持的FD上限是最大可以打开文件的数目(select面临这样的问题),IO效率不随FD数目增加而线性下降(select、poll面临的问题)使用mmap加速内核与用户空间的消息传递。现在libevent封装了几种的实现,可以通过使用libevent来实现多路复用。
本文参考: