【网络】epoll服务器

1. epoll相关知识概述

epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。

epoll除了提供select/poll那种IO事件的水平触发（Level Triggered）外，还提供了边缘触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

LT（level triggered）是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

ET （edge-triggered）是高速工作方式，只支持non-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了（比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once），不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。

2. epoll相关系统调用

（1）epoll_create

int epoll_create(int size); //创建一个epoll的句柄

（2）epoll_ctl

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 epoll_event结构如下：

struct epoll_event  
{  
     _uint32_t events;   //epoll事件  
     epoll_data_t data;  //用户数据  
}  

常用的events事件可以表示宏的集合：
①EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
②EPOLLOUT：表示对应的文件描述符可以写

（3）epoll_wait

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

3. 代码实现

#include<stdio.h>  
#include<stdlib.h>  
#include<sys/types.h>  
#include<sys/socket.h>  
#include<netinet/in.h>  
#include<sys/epoll.h>  
#include<string.h>  
#include<arpa/inet.h>  

static void usage(const char *proc)  
{  
    printf("Usage :%s [local_ip] [local_port]\n",proc);  
}  

typedef struct fd_buf{  
    int fd;  
    char buf[1024];  
}fd_buf_t,*fd_buf_p;  

static void *alloc_fd_buf(int fd)  
{  
    fd_buf_p tmp=(fd_buf_p)malloc(sizeof(fd_buf_t));  
    if(!tmp){  
        perror("malloc");  
        return NULL;  
    }  
    tmp->fd=fd;  
    return tmp;  
}  

int startup(const char *_ip,int _port)  
{  
    int sock=socket(AF_INET,SOCK_STREAM,0);  
    if(sock<0){  
        perror("socket");  
        exit(2);  
    }  

    int opt=1;  
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));  
    struct sockaddr_in local;  
    local.sin_family=AF_INET;  
    local.sin_port=htons(_port);  
    local.sin_addr.s_addr=inet_addr(_ip);  

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0){  
        perror("bind");  
        exit(3);  
    }  

    if(listen(sock,10)<0){  
        perror("listen");  
        exit(4);  
    }  

    return sock;  
}  


int main(int argc,char *argv[])  
{  
    if(argc!=3){  
        usage(argv[0]);  
        return 1;  
    }  
    int listen_sock=startup(argv[1],atoi(argv[2]));  
    int epollfd=epoll_create(256);  
    if(epollfd<0){  
        perror("epoll_create");  
        close(listen_sock);  
        return 5;  
    }  
    struct epoll_event ev;  
    ev.events = EPOLLIN;  
    ev.data.ptr=alloc_fd_buf(listen_sock);  
    epoll_ctl(epollfd,EPOLL_CTL_ADD,listen_sock,&ev);  

    int nums=0;  
    struct epoll_event evs[64];  
    int timeout=-1;  
    while(1){  
        switch((nums=epoll_wait(epollfd,evs,64,timeout))){  
            case -1:  
                perror("epoll_wait");  
                break;  
            case 0:  
                printf("timeout");  
                break;  
            default:  
                {  
                    int i=0;  
                    for(;i<nums;i++)  
                    {  
                        fd_buf_p fp=(fd_buf_p)evs[i].data.ptr;  
                        if(fp->fd==listen_sock&&\  
                                (evs[i].events & EPOLLIN))  
                        {  
                            struct sockaddr_in client;  
                            socklen_t len=sizeof(client);  
                            int new_sock=accept(listen_sock,\  
                                    (struct sockaddr*)&client,&len);  
                            if(new_sock<0)  
                            {  
                                perror("accept");  
                                continue;  
                            }  
                            printf("get a new client!\n");  
                            ev.events=EPOLLIN;  
                            ev.data.ptr=alloc_fd_buf(new_sock);  
                            epoll_ctl(epollfd,EPOLL_CTL_ADD,\  
                                    new_sock,&ev);  
                        }  
                        else if(fp->fd!=listen_sock)  
                        {  
                            if(evs[i].events & EPOLLIN)  
                            {  
                                ssize_t s=read(fp->fd,fp->buf,\  
                                        sizeof(fp->buf));  
                                if(s>0)  
                                {  
                                    fp->buf[s]=0;  
                                    printf("client say# %s\n",fp->buf);  
                                    ev.events=EPOLLOUT;  
                                    ev.data.ptr=fp;  
                                    epoll_ctl(epollfd,EPOLL_CTL_MOD,\  
                                            fp->fd,&ev);  
                                }  
                                else if(s<=0)  
                                {  
                                    close(fp->fd);  
                                    epoll_ctl(epollfd,EPOLL_CTL_DEL,\  
                                            fp->fd,NULL);  
                                    free(fp);  
                                }  
                                else{}  
                            }  
                            else if(evs[i].events & EPOLLOUT)  
                            {  
                                const char *msg="HTTP/1.0 200 OK\r\n\r\n<html><h1>hello epoll!</h1></html>";  
                                write(fp->fd,msg,strlen(msg));  
                                close(fp->fd);  
                                epoll_ctl(epollfd,EPOLL_CTL_DEL,\  
                                        fp->fd,NULL);  
                                free(fp);  
                            }  
                            else{}  
                        }  
                        else{}  
                    }  
                }  
                break;  
        }  
    }   
    return 0;  
}  

4. epoll服务器优缺点

优点：
（1）epoll底层实现在调用epoll_create时操作系统会创建一颗红黑树存放socket和一个队列存放就绪事件；
（2）支持一个进程打开大数目的socket描述符(fd) ；
（3）IO效率不随fd的数目增加而线性下降 ；
（4）使用mmap加速内核与用户空间的消息传递。

缺点：
（1）相对select来说, epoll的跨平台性不够用 只能工作在Linux下, 而select可以在windows linux apple上使用, 还有手机端Android iOS之类的都可以. android虽然是linux的内核 但早期版本同样不支持epoll的.；
（2）相对select来说 还是用起来还是复杂了一些, 不过和IOCP比起来 增加了一点点的复杂度却基本上达到了IOCP的并发量和性能, 而复杂度远远小于IOCP；
（3）相对IOCP来说 对多核/多线程的支持不够好, 性能也因此在性能要求比较苛刻的情况下不如IOCP。