epoll学习

一、epoll_create

#include <sys/epoll.h>

int epoll_create(int size);
int epoll_create1(int flags);
返回：成功非负文件描述符，-1出错
size:内核监听数目一共多大

创建一个epoll接口，size参数和select不同，不是fd+1？

需要注意的是：当创建好epoll后，它就会占用一个fd值，在linux /proc/id/fd/能看到这个fd的，所以使用完epoll后，必须close()关闭，否则可能导致耗尽fd。

 

二、epoll_ctl

#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
返回：0成功,-1失败
epfd:由epoll_create生成的epoll专用的文件描述符
op:要进行的操作，可能取EPOLL_CTL_ADD注册、EPOLL_CTL_MOD修改、EPOLL_CTL_DEL删除
fd:关联的文件描述符
event:指向epoll_event指针

 epoll的相关的epoll_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)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

三、epoll_wait

#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events,
        int maxevents, int timeout);

int epoll_pwait(int epfd, struct epoll_event *events,
        int maxevents, int timeout, const sigset_t *sigmask);
返回：发生事件数
epfd:由epoll_create生成的epoll专用的文件描述符
epoll_event:用于回传代处理事件的数组
maxevents:每次能处理的事件数
timeout:等待I/O事件发生的超时值

 

在linux中的man手册中有epoll模型：

           #define MAX_EVENTS 10
           struct epoll_event ev, events[MAX_EVENTS];
           int listen_sock, conn_sock, nfds, epollfd;

           /* Set up listening socket, 'listen_sock' (socket(),
              bind(), listen()) */

           epollfd = epoll_create(10);
           if (epollfd == -1) {
               perror("epoll_create");
               exit(EXIT_FAILURE);
           }

           ev.events = EPOLLIN;
           ev.data.fd = listen_sock;
           if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
               perror("epoll_ctl: listen_sock");
               exit(EXIT_FAILURE);
           }

           for (;;) {
               nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);  //等待IO事件
               if (nfds == -1) {
                   perror("epoll_pwait");
                   exit(EXIT_FAILURE);
               }

               for (n = 0; n < nfds; ++n) {
               //如果是主socket事件，则表示有新连接进入，需要进行新连接的处理
                   if (events[n].data.fd == listen_sock) {
                       conn_sock = accept(listen_sock,
                                       (struct sockaddr *) &local, &addrlen);
                       if (conn_sock == -1) {
                           perror("accept");
                           exit(EXIT_FAILURE);
                       }
                       //将新连接置于非阻塞模式
                       setnonblocking(conn_sock);
                       ev.events = EPOLLIN | EPOLLET;
                       //注意这里的参数EPOLLIN|EPOLLET并没有设置对写socket的监听
                       //如果有写操作的话，这个时候epoll是不会返回事件的
                       //如果要对写操作也监听的话，应该是EPOLLIN|EPOLLOUT|EPOLLET
                       //并且将新连接也加入EPOLL的监听队列
                       ev.data.fd = conn_sock;
                       if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
                                   &ev) == -1) {
                           //加入到epoll的监听队列里，这里用EPOLL_CTL_ADD
                           //来加一个新的epoll事件，可以通过EPOLL_CTL_DEL减少
                           //一个epoll事件，通过EPOLL_CTL_MOD来改变一个i额事件的监听方式
                           perror("epoll_ctl: conn_sock");
                           exit(EXIT_FAILURE);
                       }
                   } else {
                       //如果不是主socket的事件的话，则代表这是一个用户的socket事件
                       //则用来处理这个用户的socket的事情是，比如说read(fd, xxx)之类，或者一些其他的处理
                       do_use_fd(events[n].data.fd);
                   }
               }
           }    

 下面是个epoll的使用例子：

#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>
#include <stdlib.h>
#include <strings.h>

using namespace 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 i, maxi, listenfd, connfd, sockfd, epfd, nfds;
    ssize_t n;
    char line[MAXLINE];
    socklen_t clilen;

    struct epoll_event ev, events[20];
    epfd = epoll_create(256);
    struct sockaddr_in clientaddr;
    struct sockaddr_in serveraddr;
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    setnonblocking(listenfd);
    ev.data.fd = listenfd;
    ev.events = EPOLLIN | EPOLLET;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char *local_addr = "192.168.1.63";
    inet_aton(local_addr, &(serveraddr.sin_addr));
    serveraddr.sin_port = htons(SERV_PORT);
    bind(listenfd, (sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);

    maxi = 0;
    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);
                if(connfd < 0) {
                    perror("connfd < 0");
                    exit(1);
                }
                setnonblocking(connfd);
                char *str = inet_ntoa(clientaddr.sin_addr);
                std::cout<<"connect from"<<str<<std::endl;
                ev.data.fd = connfd;
                ev.events = EPOLLIN | EPOLLET;
                epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
            } else if(events[i].events & EPOLLIN) {
                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;
                    }
                } else if(n == 0) {
                    close(sockfd);
                    events[i].data.fd = -1;
                }
                ev.data.fd = sockfd;
                ev.events = EPOLLOUT | EPOLLET;
                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
            } else if(events[i].events & EPOLLOUT) {
                sockfd = events[i].data.fd;
                write(sockfd, line, n);
                ev.data.fd = sockfd;
                ev.events = EPOLLIN | EPOLLET;
                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
            }
        }
    }
}