epoll使用详解

epoll的接口非常简单，一共就三个函数：

1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

 

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct 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队列里

 

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

那么究竟如何来使用epoll呢？其实非常简单。
通过在包含一个头文件#include 以及几个简单的API将可以大大的提高你的网络服务器的支持人数。

首先通过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来保证主循环的效率。

下面是网上给出的示例：

 

1.    void setnonblocking(int sock){
2.    int opts;
3.    opts = fcntl(sock,F_GETFL);
4.    if(opts < 0){
5.    perror("fcntl(sock,GETFL)");
6.    exit(1);
7.    }
8.    opts = opts | O_NONBLOCK;
9.    if(fcntl(sock, F_SETFL, opts) < 0){
10.    perror("fcntl(sock, SETFL, opts)");
11.    exit(1);
12.    }
13.    }
14.
15.    int main(int argc, char* argv[]){
16.    int i, maxi, listenfd, connfd, sockfd, epfd, nfds, portnumber;
17.    ssize_t n;
18.    char line[MAXLINE];
19.    socklen_t clilen;
20.
21.    if(argc == 2){
22.    if((portnumber = atoi(argv[1])) < 0){
23.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
24.    return 1;
25.    }
26.    }
27.    else{
28.    fprintf(stderr, "Usage:%s portnumber/a/n", argv[0]);
29.    return 1;
30.    }
31.    struct sockaddr_in serveraddr, clientaddr;
32.    memset(&serveraddr, 0, sizeof(serveraddr));
33.    memset(&clientaddr, 0, sizeof(clientaddr));
34.    serveraddr.sin_family = AF_INET;
35.    serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
36.    serveraddr.sin_port = htons(portnumber);
37.
38.    listenfd = socket(AF_INET, SOCK_STREAM, 0);
39.    bind(listenfd, (sockaddr *)&serveraddr, sizeof(serveraddr));
40.    listen(listenfd, LISTENQ);
41.
42.    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
43.    struct epoll_event ev;
44.    struct epool_event events[20];
45.
46.    //生成用于处理accept的epoll专用的文件描述符
47.    epfd = epoll_create(256);
48.
49.    //把socket设置为非阻塞方式，影响accept()的返回时机
50.    setnonblocking(listenfd);
51.
52.    //设置与要处理的事件相关的文件描述符
53.    ev.data.fd = listenfd;
54.
55.    //设置要处理的事件类型：监听套接字变为可读
56.    ev.events = EPOLLIN | EPOLLET;
57.
58.    //注册epoll事件
59.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
60.    for ( ; ; ) {
61.    //等待epoll事件的发生
62.    nfds = epoll_wait(epfd, events, 20, 500);
63.
64.    //处理所发生的所有事件
65.    for(i = 0; i < nfds; i++){
66.    //如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
67.    if(events[i].data.fd == listenfd)
68.    {
69.    int clilen = sizeof(clientaddr);
70.    connfd = accept(listenfd, (struct sockaddr *)&clientaddr, &clilen);
71.    if(connfd < 0){
72.    perror("accept()");
73.    exit(1);
74.    }
75.    setnonblocking(connfd);
76.    printf("accept a connection from %s.", inet_ntoa(clientaddr.sin_addr));
77.    //设置用于读操作的文件描述符，准备接受客户端请求
78.    ev.data.fd = connfd;
79.
80.    //设置用于注测的读操作事件
81.    ev.events = EPOLLIN | EPOLLET;
82.
83.    //注册ev
84.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
85.    }
86.    else if(events[i].events & EPOLLIN){//如果是已经连接的用户，并且收到数据，那么进行读入。
87.    if((sockfd = events[i].data.fd) < 0){
88.    continue;
89.    }
90.    if((n = read(sockfd, line, MAXLINE)) < 0){
91.    if (errno == ECONNRESET){
92.    close(sockfd);
93.    events[i].data.fd = -1;
94.    }
95.    else{
96.    printf("read() error\n");
97.    }
98.    }
99.    else if(n == 0){
100.    close(sockfd);
101.    events[i].data.fd = -1;
102.    }
103.    line[n] = '\0';
104.    printf("%s\n", line);
105.    //设置用于写操作的文件描述符
106.    ev.data.fd = sockfd;
107.
108.    //设置用于注册的写操作事件
109.    ev.events = EPOLLOUT | EPOLLET;
110.
111.    //修改sockfd上要处理的事件为EPOLLOUT
112.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
113.    }
114.    else if(events[i].events & EPOLLOUT){//如果被通知可写
115.    sockfd = events[i].data.fd;
116.    write(sockfd, line, n);
117.
118.    //设置用于读操作的文件描述符
119.    ev.data.fd = sockfd;
120.
121.    //设置用于注册的读操作事件
122.    ev.events = EPOLLIN | EPOLLET;
123.
124.    //修改sockfd上要处理的事件为EPOLIN
125.    epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
126.    }
127.    }
128.    }
129.    return 0;
130.    }

 

理解后自己写了一个简单的回显服务器：

 

1.    #include <stdio.h>
2.    #include <stdio.h>
3.    #include <stdlib.h>
4.    #include <string.h>
5.    #include <sys/socket.h>
6.    #include <sys/types.h>
7.    #include <netinet/in.h>
8.    #include <netdb.h>
9.    #include <sys/epoll.h>
10.    #include <fcntl.h>
11.
12.    typedef struct mydata{
13.    int fd;
14.    char *ptr;
15.    }mydata_t;
16.
17.    int main(){
18.    int listenfd, connfd;
19.    struct sockaddr_in server;
20.    memset(&server, 0, sizeof(server));
21.    server.sin_family = AF_INET;
22.    server.sin_addr.s_addr = htonl(INADDR_ANY);
23.    server.sin_port = htons(5000);
24.    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
25.    perror("socket()");
26.    exit(1);
27.    }
28.    int on = 1;
29.    if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0){
30.    perror("setsockopt()");
31.    exit(1);
32.    }
33.    if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) < 0){
34.    perror("bind()");
35.    exit(1);
36.    }
37.    if(listen(listenfd, 5) < 0){
38.    perror("listen()");
39.    exit(1);
40.    }
41.    int epfd = epoll_create(1024);
42.    struct epoll_event ev;
43.    struct epoll_event ev_r[20];
44.    int nfds, i, n;
45.    //一定注意，ev.data是union类型，而不是struct类型！
46.    //data就是8字节的用户数据，对于epoll_wait而言是透明的，即epoll只负责在内核和用户区之间传递这8字节的数据，不修改内容
47.    ev.data.fd = listenfd;
48.    ev.events = EPOLLIN;
49.    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
50.
51.    while(1){
52.    nfds = epoll_wait(epfd, ev_r, 20, -1);
53.    for(i = 0; i < nfds; i++){
54.    int fd = ev_r[i].data.fd;
55.    //有新连接待处理
56.    if(fd == listenfd){
57.    if((connfd = accept(listenfd, NULL, NULL)) < 0){
58.    perror("accept()");
59.    exit(1);
60.    }
61.    //为新连接的描述符分配缓冲区
62.    mydata_t md;
63.    md.fd = connfd;
64.    md.ptr = (char *)malloc(1025);
65.    //构造用户数据内容
66.    memcpy(&ev.data, &md, sizeof(md));
67.    ev.events = EPOLLIN;
68.    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
69.    continue;
70.    }
71.    //普通连接
72.    //提取用户数据
73.    mydata_t m;
74.    memcpy(&m, &ev_r[i].data, sizeof(m));
75.    // char *buf = *((char **)((char *)&ev_r[i].data + 4));
76.    if(ev_r[i].events & EPOLLIN){
77.    n = read(fd, m.ptr, 1024);
78.    if(n < 0){
79.    perror("read()");
80.    free(m.ptr);
81.    close(fd);
82.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
83.    continue;
84.    }
85.    if(n == 0){
86.    close(fd);
87.    free(m.ptr);
88.    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
89.    }
90.    else{
91.    m.ptr[n] = '\0';
92.    printf("%s\n", m.ptr);
93.    memcpy(&ev.data, &m, sizeof(m));
94.    ev.events = EPOLLOUT;
95.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
96.    }
97.    }
98.    else if(ev_r[i].events & EPOLLOUT){
99.    write(fd, m.ptr, strlen(m.ptr));
100.    memcpy(&ev.data, &m, sizeof(m));
101.    ev.events = EPOLLIN;
102.    epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
103.    }
104.    }
105.    }
106.    close(epfd);
107.    close(connfd);
108.    close(listenfd);
109.    return 0;
110.    }