I/O多路复用之epoll服务器

1、epoll服务器的函数
epoll是linux特有的I/O复用函数，它的实现和select和poll有很大的差异。epoll是使用一组函数来完成任务，而不是单个的函数。epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，而无需向select和poll那样每次调用都要重复传入文件描述符集或事件集，但是epoll却需要一个额外的文件描述符，来唯一标识内核中的这个事件表。

1、epoll_create函数：

这个函数是用来创建epoll事件的模型，它只有一个参数来表示创建的这个事件表是需要多大的。函数返回的文件描述符作为epoll其他函数的第一个参数，用来指定要访问的内核时间表。

2、epoll_ctl函数：

这个函数有四个参数，epfd是epoll_create这个函数的返回值，fd是要操作的文件描述符，op参数是指定的操作类型，而操作类型有以下三种：

EPOLL_CTL_ADD：往事件表上注册fd上的事件
EPOLL_CTL_MOD：修改fd上的注册事件
EPOLL_CTL_DEL：删除fd上的注册事件
event参数指定事件，它是epoll_event结构指针类型。epoll_event的定义如下：

events成员描述事件类型，而epoll_event中的data成员用于存储用户数据，而其中epoll_data_t定义如上图所示。
epoll_data_t是一个联合体，其中用的最多的是fd，它用来指定事件所从属的目标文件描述符。ptr成员可用来指定与fd相关的用户数据。但是epoll_data_t是一个联合体我们不能同时使用ptr成员和fd成员。
epoll_ctl成功的时候返回的是0，失败就会返回-1，并设置errno。

3、epoll_wait函数：

第一个参数epfd还是epoll_create函数的返回值，maxevents表示的是最多监听的 事件，它是必须大于0的。
timeout是要等待的时间，它的含义与poll函数中的timeout的含义是相同的。
epoll_wait这个函数如果检测到事件，就将所有继续的事件从内核事件表复制到它的第二个参数events的数组中去。

2、ET模式和LT模式
epoll对文件描述符的操作有两种模式：LT模式（水平触发）和ET模式（边沿触发），LT是默认的工作模式，在这种模式下epoll相当于一个效率较高的epoll，当往epoll内核事件表中注册一个文件描述符上的EPOLLET事件，epoll将以ET模式来操作该文件描述符，ET模式是epoll的高效工作方式。
ET模式在很大程度上降低了同一个epoll事件的被重复触发的次数，因此它的效率要比LT模式要高。

3、三种服务器的比较

4、epoll服务器的优点

1、底层采用回调机制来激活节点，将已经就绪的文件描述符加到就绪队列中去。
2、当有了新的事件就绪的时候这个事件就会被加到epoll事件的红黑树中去，红黑树的增删查改的时间复杂度（O (N*lgN)）是要比数组高很多
3、epoll_wait获得就绪的文件描述符是从就绪队列中获取的，它的时间复杂度为O (1)这是epoll的时间复杂度也是epoll高效的原因。
4、epoll关心的文件描述符是没有上限的
5、就绪队列中的节点会映射到epoll_wait中的events结构体中，节省了一次内核态到用户态的数据拷贝，这是用的mmap技术（内存映射）。
6、就绪事件的陈列的方式是不同的，epoll访问的是就绪队列避免了访问没价值的数据，而select是一个数组保存的。

5、代码实现
epoll.c：

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

#define MAX_EVENTS 10
#define SIZE 64

typedef struct epbuff{
    int fd;
    char buf[2048];
    int index;
}epbuff_t,*epbuff_p,**epbuff_pp;


static epbuff_p alloc_buff(int fd) //此处开空间之后后面就要是ptr指向的一段空间
{
    epbuff_p ptr = (epbuff_p)malloc(sizeof(epbuff_t));
    if(NULL == ptr)
    {
        perror("malloc");
        exit(9);
    }
    ptr->fd = fd;
    return ptr;
}

static void dealloc(epbuff_p ptr)//既然要malloc就得去free
{
    if(NULL != ptr)
    {
        free(ptr);
        ptr = NULL;
    }
}

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

int setnonblocking(int sock) //将文件描述符设置为非阻塞的
{
    int old_option = fcntl(sock,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(sock,F_SETFL,new_option);
    return old_option;
}


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;
}

//实现的是ET版本的epoll服务器  要实现非阻塞版本
int myread(int sock,char* buf)
{
    int len = 0;
    int total = 0;
    while((len = read(sock,buf+total,1024) > 0) && (len = 1024 ))
    {
        total += len;
    }
    if(len > 0 && len< 1024)
    {
        total += len;
    }
    buf[total] = '\0';
    return total;
}



int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        return 1;
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

    int epfd = epoll_create(SIZE);//先创建一个红黑树和队列
    if(epfd < 0)
    {
        perror("epoll_create");
        exit(5);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN | EPOLLET;
    ev.data.ptr = alloc_buff(listen_sock);

    setnonblocking(listen_sock);//由于是ET工作模式下  将listen_sock设置为非阻塞的状态

    if(epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&ev) < 0)//往事件表上注册fd事件（把listen_sock）加到红黑树上去
    {
        perror("epoll_ctl");
        exit(6);
    }

    int timeout = 5000;
    int nums = -1;

    struct epoll_event revs[MAX_EVENTS];
    while(1)
    {
        nums = epoll_wait(epfd,revs,MAX_EVENTS,timeout);
        switch(nums)
        {
            case 0:
                printf("time out!!!...\n");
                break;
            case -1:
                perror("epoll_wait");
                break;
            default:
                {
                    int i = 0;
                    for(;i < nums ;i++)
                    {
                        int sock = ((epbuff_p)(revs[i].data.ptr))->fd;
                        if(sock == listen_sock && revs[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("myaccept");
                                continue;
                            }
                            printf("get a new client! ip： %s port：%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                            ev.events = EPOLLIN | EPOLLOUT;
                            setnonblocking(new_sock);
                            ev.data.ptr = alloc_buff(new_sock);
                            int ret = epoll_ctl(epfd,EPOLL_CTL_ADD,new_sock,&ev);
                            if(ret < 0)
                            {
                                perror("epoll_ctl");
                                exit(7);
                            }
                        }
                        else if(sock != listen_sock && (revs[i].events & EPOLLIN))
                        {
                            //char buf[1024];
                            char* buf = ((epbuff_p)(revs[i].data.ptr))->buf;
                            ssize_t s = myread(sock,buf);
                            if( s > 0)
                            {
                                buf[s] = '\0';
                                printf("client#：%s\n",buf);  //如果读成功之后就会直接关心其写操作
                                ev.events=EPOLLOUT;
                                epoll_ctl(epfd,EPOLL_CTL_MOD,sock,&ev);
                            }
                            else if(s == 0) // 直接关闭连接
                            {
                                printf("client is close!\n");
                                dealloc(revs[i].data.ptr);
                                epoll_ctl(epfd,EPOLL_CTL_DEL,sock,NULL);
                                close(sock);
                            }
                            else
                            {
                                perror("read");
                                dealloc(revs[i].data.ptr);
                                int ret = epoll_ctl(epfd,EPOLL_CTL_DEL,sock,NULL);
                                if(ret < 0)
                                {
                                    perror("epoll_ctl");
                                    exit(8);
                                }
                                close(sock);
                            }
                        }
                        else if(sock != listen_sock && (revs[i].events &EPOLLOUT))
                        {
                            const char* msg = "HTTP/1.0 200 OK\r\n\r\n Hello epoll!  ";
                            //const char* msg = "Hello epoll!\n";
                            ssize_t s = write(sock,msg,strlen(msg));
                            if(s < 0)
                            {
                                perror("write");
                                exit(10);
                            }
                            dealloc(revs[i].data.ptr);
                            epoll_ctl(epfd,EPOLL_CTL_DEL,sock,NULL);
                            close(sock);
                        }
                    }
                    break;
                }
        }
    }

    return 0;
}

6、运行结果

服务器端：

客户端：