unix网络编程之socket：epoll 系列函数简介、与select、poll 的区别

一、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表示永不超时

#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>typedef std::vector<struct epoll_event> EventList;#define ERR_EXIT(m) \    do { \        perror(m); \        exit(EXIT_FAILURE); \    } while (0)ssize_t readn(int fd, void *buf, size_t count){    size_t nleft = count;    ssize_t nread;    char *bufp = (char *)buf;    while (nleft > 0)    {        if ((nread = read(fd, bufp, nleft)) < 0)        {            if (errno == EINTR)                continue;            return -1;        }        else if (nread == 0) //对方关闭或者已经读到eof            return count - nleft;        bufp += nread;        nleft -= nread;    }    return count;}ssize_t writen(int fd, const void *buf, size_t count){    size_t nleft = count;    ssize_t nwritten;    char *bufp = (char *)buf;    while (nleft > 0)    {        if ((nwritten = write(fd, bufp, nleft)) < 0)        {            if (errno == EINTR)                continue;            return -1;        }        else if (nwritten == 0)            continue;        bufp += nwritten;        nleft -= nwritten;    }    return count;}ssize_t recv_peek(int sockfd, void *buf, size_t len){    while (1)    {        int ret = recv(sockfd, buf, len, MSG_PEEK); // 设置标志位后读取后不清除缓冲区        if (ret == -1 && errno == EINTR)            continue;        return ret;    }}/* 读到'\n'就返回，加上'\n' 一行最多为maxline个字符 */ssize_t readline(int sockfd, void *buf, size_t maxline){    int ret;    int nread;    char *bufp = buf;    int nleft = maxline;    int count = 0;    while (1)    {        ret = recv_peek(sockfd, bufp, nleft);        if (ret < 0)            return ret; // 返回小于0表示失败        else if (ret == 0)            return ret; //返回0表示对方关闭连接了        nread = ret;v-        int i;        for (i = 0; i < nread; i++)        {            if (bufp[i] == '\n')            {                ret = readn(sockfd, bufp, i + 1);                if (ret != i + 1)                    exit(EXIT_FAILURE);                                return ret + count;            }        }        if (nread > nleft)            exit(EXIT_FAILURE);        nleft -= nread;        ret = readn(sockfd, bufp, nread);        if (ret != nread)            exit(EXIT_FAILURE);        bufp += nread;        count += nread;    }    return -1;}/* read_timeout - 读超时检测函数，不含读操作 * fd:文件描述符 * wait_seconds:等待超时秒数， 如果为0表示不检测超时； * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT */int read_timeout(int fd, unsigned int wait_seconds){int ret = 0;if (wait_seconds > 0) {fd_set read_fdset;struct timeval timeout;FD_ZERO(&read_fdset);FD_SET(fd, &read_fdset);timeout.tv_sec = wait_seconds;timeout.tv_usec = 0;do {ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout); //select会阻塞直到检测到事件或者超时// 如果select检测到可读事件发送，则此时调用read不会阻塞} while (ret < 0 && errno == EINTR);if (ret == 0) {ret = -1;errno = ETIMEDOUT;}else if (ret == 1)return 0;}return ret;}/* write_timeout - 写超时检测函数，不含写操作 * fd:文件描述符 * wait_seconds:等待超时秒数， 如果为0表示不检测超时； * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT */int write_timeout(int fd, unsigned int wait_seconds){int ret = 0;if (wait_seconds > 0) {fd_set write_fdset;struct timeval timeout;FD_ZERO(&write_fdset);FD_SET(fd, &write_fdset);timeout.tv_sec = wait_seconds;timeout.tv_usec = 0;do {ret = select(fd + 1, &write_fdset, NULL, NULL, &timeout);} while (ret < 0 && errno == EINTR);if (ret == 0) {ret = -1;errno = ETIMEDOUT;}else if (ret == 1)return 0;}return ret;}/* accept_timeout - 带超时的accept * fd: 套接字 * addr: 输出参数，返回对方地址 * wait_seconds: 等待超时秒数，如果为0表示正常模式 * 成功（未超时）返回已连接套接字，失败返回-1，超时返回-1并且errno = ETIMEDOUT */int accept_timeout(int fd, struct sockaddr_in* addr, unsigned int wait_seconds){int ret;socklen_t addrlen = sizeof(struct sockaddr_in);if (wait_seconds > 0) {fd_set accept_fdset;struct timeval timeout;FD_ZERO(&accept_fdset);FD_SET(fd, &accept_fdset);timeout.tv_sec = wait_seconds;timeout.tv_usec = 0;do {ret = select(fd + 1, &accept_fdset, NULL, NULL, &timeout);} while (ret < 0 && errno == EINTR);if (ret == -1)return -1;else if (ret == 0) {errno = ETIMEDOUT;return -1;}}if (addr != NULL)ret = accept(fd, (struct sockaddr*)addr, &addrlen);elseret = accept(fd, NULL, NULL);if (ret == -1)ERR_EXIT("accpet error");return ret;}/* activate_nonblock - 设置IO为非阻塞模式 * fd: 文件描述符 */void activate_nonblock(int fd){int ret;int flags = fcntl(fd, F_GETFL);if (flags == -1)ERR_EXIT("fcntl error");flags |= O_NONBLOCK;ret = fcntl(fd, F_SETFL, flags);if (ret == -1)ERR_EXIT("fcntl error");}/* deactivate_nonblock - 设置IO为阻塞模式 * fd: 文件描述符 */void deactivate_nonblock(int fd){int ret;int flags = fcntl(fd, F_GETFL);if (flags == -1)ERR_EXIT("fcntl error");flags &= ~O_NONBLOCK;ret = fcntl(fd, F_SETFL, flags);if (ret == -1)ERR_EXIT("fcntl error");}/* connect_timeout - 带超时的connect * fd: 套接字 * addr: 输出参数，返回对方地址 * wait_seconds: 等待超时秒数，如果为0表示正常模式 * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT */int connect_timeout(int fd, struct sockaddr_in* addr, unsigned int wait_seconds){int ret;socklen_t addrlen = sizeof(struct sockaddr_in);if (wait_seconds > 0) activate_nonblock(fd);ret = connect(fd, (struct sockaddr*)addr, addrlen);if (ret < 0 && errno == EINPROGRESS) {fd_set connect_fdset;struct timeval timeout;FD_ZERO(&connect_fdset);FD_SET(fd, &connect_fdset);timeout.tv_sec = wait_seconds;timeout.tv_usec = 0;do {/* 一旦连接建立，套接字就可写 */ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);} while (ret < 0 && errno == EINTR);if (ret == 0) {errno = ETIMEDOUT;return -1;}else if (ret < 0)return -1;else if (ret == 1) {/* ret返回为1，可能有两种情况，一种是连接建立成功，一种是套接字产生错误 * 此时错误信息不会保存至errno变量中（connect没出错）,因此，需要调用 * getsockopt来获取 */int err;socklen_t socklen = sizeof(err);int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);if (sockoptret == -1)return -1;if (err == 0)ret = 0;else {errno = err;ret = -1;}}}if (wait_seconds > 0)deactivate_nonblock(fd);return ret;}/* 相比于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 函数将其加入关心的套接字队列。

还需要调用 activate_nonblock(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() 函数。

我们可以使用前面写的conntest 客户端程序测试一下，先运行服务器程序，再运行客户端，输出如下：

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、内核 / 用户空间 内存拷贝问题，如何让内核把 fd消息通知给用户空间呢？在这个问题上select/poll采取了内存拷贝方法。而epoll采用了内核和用户空间共享内存的方式。

4、epoll不仅会告诉应用程序有I/0 事件到来，还会告诉应用程序相关的信息，这些信息是应用程序填充的，因此根据这些信息应用程序就能直接定位到事件，而不必遍历整个fd集合。

5、当已连接的套接字数量不太大，并且这些套接字都非常活跃，那么对于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》

顶