多路复用模型之epoll

作为多路复用IO模型，epoll致力于解决select与poll设计缺陷以提升系统并发能力。
(1) 并发效率不随文句柄数上升而线性下降：
epoll避免了select模型中对所有每次所有文件描述符句柄轮询。它的底层采用红黑树记录所有文件句柄，并将活跃的连接存放至链表中，在处理IO事件时，只需遍历该链表即可。
(2) mmap加速内核与用户态拷贝：
无论select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在linux2.5版本之后，epoll运用mmap内核映射减少了一次内核态至用户态文件描述符拷贝。
(3)操作系统句柄限制：
select受限于进程打开文件描述符限制，虽然通过修改相应的宏并重新编译内核可以解决，但代价太大；epoll在这方面没有明确限制，在1GB内存的机器上大约是10万左右，这个数目和系统内存关系很大。
相应接口：
int epoll_create(int size); //创建epoll句柄，size并不限制句柄数目
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);//事件注册函数
op参数：
a）EPOLL_CTL_ADD， 往事件表中注册fd上的事件；
b）EPOLL_CTL_MOD， 修改fd上注册的事件；
c）EPOLL_CTL_DEL， 删除fd上注册的事件。
struct epoll_event
{
int32_t events; //epoll事件
epoll_data_t data; //用户数据
};
typedef union epoll_data
{
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
}epoll_data;
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout); //等待文件描述符就绪
代码示例：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

#define BACKLOG 1024
#define MAX_EVENT 1024
#define EPOLL_SIZE 16
#define PORT 9000

int epfd = -1;

int main(){
    int server_socket = -1;
    struct sockaddr_in socket_addr;
    memset(&socket_addr, 0, sizeof(socket_addr));
    socket_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socket_addr.sin_port = htons(PORT);
    socket_addr.sin_family = AF_INET;
    if((server_socket = create_socket(socket_addr, BACKLOG)) < 0)
        return -1;

    struct epoll_event event, ev[MAX_EVENT];
    memset(&event, 0, sizeof(event));
    event.events = EPOLLIN;
    event.data.fd = server_socket;
    if((epfd = epoll_init(EPOLL_SIZE, EPOLL_CTL_ADD, server_socket, event)) < 0){
        perror("epoll_init error");
        return -1;
    }

    while(1){
        int active_fd_count = epoll_wait(epfd, &ev, MAX_EVENT, -1);
        int event_index = 0;
        for(; (event_index < active_fd_count) && (ev[event_index].data.fd) >= 0; event_index++)
            if(ev[event_index].data.fd == server_socket)
                connect_handler(server_socket);              //处理客户端连接
            else if(ev[event_index].events&EPOLLIN)
                request_handler(ev[event_index].data.fd);    //IO读写
            else
                error_handler(ev + event_index);            //异常处理
    }
    close(epfd);
    return 0;
}

void error_handler(struct epoll_event *event_fd){
    close(event_fd->data.fd);
    struct epoll_event event;
    memset(&event, 0, sizeof(event));
    event.data.fd = event_fd->data.fd;
    event.events = EPOLLIN | EPOLLERR | EPOLLHUP; 
    epoll_ctl(epfd, EPOLL_CTL_DEL, event_fd->data.fd, &event);
    event_fd->data.fd = -1;
}

void request_handler(int client_fd){
    if(client_fd < 0){
        perror("request_handler client error");
        return;
    }
    char buf[64];
    memset(buf, 0, sizeof(buf));
    int len = -1;
    if((len = read(client_fd, buf, sizeof(buf))) < 0){
        perror("read error");
        return;
    }else if(len == 0){
        close(client_fd);
        printf("client close\n");
        return;
    }else{
        printf("%s%s", get_client_info(client_fd), buf);
        write(client_fd, buf, sizeof(buf));
    }
}

void connect_handler(int server_socket){
    if(server_socket < 0){
        perror("connect error");
        return;
    }
    int client_fd;
    struct sockaddr_in client_addr;
    socklen_t len = sizeof(client_addr);
    memset(&client_addr, 0, len);
    if((client_fd = accept(server_socket, &client_addr,&len)) < 0){
        perror("accept client error");
        return;
    }
    printf("[%s:%d] connected\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    set_nonblock(client_fd);

    struct epoll_event event;
    memset(&event, 0, sizeof(event));
    event.data.fd = client_fd;
    event.events = EPOLLIN;
    if(epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &event) < 0)
        perror("epoll_ctl error");
}

int epoll_init(int epoll_size, int op, int fd, struct epoll_event event){
    if((epfd = epoll_create(epoll_size)) < 0){
        perror("epoll create error");
        return -1;
    }
    if(epoll_ctl(epfd, op, fd, &event) < 0){
        perror("epoll ctl error");
        return -1;
    }
    return epfd;
}

int create_socket(struct sockaddr_in socket_addr, int backlog){
    int server_socket = -1;
    if((server_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0){
        perror("socket error");
        return -1;
    }
    int on = 1;
    setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    if(bind(server_socket, &socket_addr, sizeof(socket_addr)) < 0){
        perror("bind error");
        return -1;
    }
    if(listen(server_socket, backlog) < 0){
        perror("listen error");
        return -1;
    }
    return server_socket;
}

void set_nonblock(int fd){
    int ret = -1;
    if((ret = fcntl(fd, F_GETFL)) < 0){
        perror("fcntl get error");
        return;
    }
    ret = ret | O_NONBLOCK;
    if(fcntl(fd, F_SETFL,ret) < 0)
        perror("fcntl set error");
}

char *get_client_info(int client_fd){
    if(client_fd <= 0)
        return NULL;
    char client_info[16];
    memset(client_info, 0, 16);
    struct sockaddr_in peeraddr;
    socklen_t len = sizeof(peeraddr);
    memset(&peeraddr, 0, len);
    getpeername(client_fd, &peeraddr, &len);
    sprintf(client_info, "[%s:%d]", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
    return client_info;
}

客户端代码：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080

int main(){
    struct sockaddr_in client_addr;
    memset(&client_addr, 0, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    client_addr.sin_port = htons(PORT);
    int socket_fd = -1;
    if((socket_fd = socket(AF_INET, SOCK_STREAM, 0))<0){
        perror("socket error");
        return -1;
    }
    connect(socket_fd, &client_addr, sizeof(client_addr));
    char send_buf[64],recv_buf[64];
    memset(send_buf, 0, sizeof(send_buf));
    memset(recv_buf, 0, sizeof(recv_buf));
    while(fgets(send_buf,sizeof(send_buf),stdin)!=NULL){
        write(socket_fd, send_buf, strlen(send_buf));
        read(socket_fd, recv_buf, sizeof(recv_buf));
        fputs(recv_buf, stdout);
        memset(send_buf, 0, sizeof(send_buf));
        memset(recv_buf, 0, sizeof(recv_buf));
    }
    close(socket_fd);
    return 0;
}

运行效果图：