Linux Epoll相关知识

其实在Linux下设计并发网络程序，向来不缺少方法，比如典型的Apache模型（Process Per Connection，简称PPC），TPC（Thread PerConnection）模型，以及select模型和poll模型，那为何还要再引入Epoll这个东东呢？那还是有得说说的…

1. 常用模型的缺点

　　如果不摆出来其他模型的缺点，怎么能对比出Epoll的优点呢。

1.1 PPC/TPC模型

　　这两种模型思想类似，就是让每一个到来的连接一边自己做事去，别再来烦我。只是PPC是为它开了一个进程，而TPC开了一个线程。可是别烦我是有代价的，它要时间和空间啊，连接多了之后，那么多的进程/线程切换，这开销就上来了；因此这类模型能接受的　　最大连接数都不会高，一般在几百个左右。

1.2 select模型

　　1. 最大并发数限制，因为一个进程所打开的FD（文件描述符）是有限制的，由FD_SETSIZE设置，默认值是1024/2048，因此Select模型的最大并发数就被相应限制了。自己改改这个FD_SETSIZE？想法虽好，可是先看看下面吧…

　　2. 效率问题，select每次调用都会线性扫描全部的FD集合，这样效率就会呈现线性下降，把FD_SETSIZE改大的后果就是，大家都慢慢来，什么？都超时了？？！！

　　3. 内核/用户空间 内存拷贝问题，如何让内核把FD消息通知给用户空间呢？在这个问题上select采取了内存拷贝方法。

1.3 poll模型

　　基本上效率和select是相同的，select缺点的2和3它都没有改掉。

2. Epoll的提升

　　把其他模型逐个批判了一下，再来看看Epoll的改进之处吧，其实把select的缺点反过来那就是Epoll的优点了。

　　2.1. Epoll没有最大并发连接的限制，上限是最大可以打开文件的数目，这个数字一般远大于2048, 一般来说这个数目和系统内存关系很大，具体数目可以cat /proc/sys/fs/file-max察看。

　　2.2. 效率提升，Epoll最大的优点就在于它只管你“活跃”的连接，而跟连接总数无关，因此在实际的网络环境中，Epoll的效率就会远远高于select和poll。

　　2.3. 内存拷贝，Epoll在这点上使用了“共享内存”，这个内存拷贝也省略了。

3. Epoll为什么高效

　　Epoll的高效和其数据结构的设计是密不可分的，这个下面就会提到。

　　首先回忆一下select模型，当有I/O事件到来时，select通知应用程序有事件到了快去处理，而应用程序必须轮询所有的FD集合，测试每个FD是否有事件发生，并处理事件；代码像下面这样：

int res = select(maxfd+, &readfds, NULL, NULL, );

if(res > )

{

    for(int i = ; i < MAX_CONNECTION; i++)

    {

        if(FD_ISSET(allConnection[i],&readfds))

        {

            handleEvent(allConnection[i]);

        }

    }

}

// if(res == 0) handle timeout, res < 0 handle error

Epoll不仅会告诉应用程序有I/0事件到来，还会告诉应用程序相关的信息，这些信息是应用程序填充的，因此根据这些信息应用程序就能直接定位到事件，而不必遍历整个FD集合。

int res = epoll_wait(epfd, events, , );

for(int i = ; i < res;i++)

{

    handleEvent(events[n]);

}

4. Epoll关键数据结构

　　前面提到Epoll速度快和其数据结构密不可分，其关键数据结构就是：

struct epoll_event {

    __uint32_t events;      // Epoll events

    epoll_data_t data;      // User datavariable

};

typedef union epoll_data {

    void *ptr;

   int fd;

    __uint32_t u32;

    __uint64_t u64;

} epoll_data_t;

　　可见epoll_data是一个union结构体,借助于它应用程序可以保存很多类型的信息:fd、指针等等。有了它，应用程序就可以直接定位目标了。

5. 使用Epoll

　　epoll的使用主要在于三个函数。

　　1. epoll_create(int size);

　　创建一个epoll的句柄，size用来告诉内核这个监听的数目最大值。 注意!是数量的最大值，不是fd的最大值，切勿搞混。 当创建好epoll句柄后，它就是会占用一个fd值，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

　　2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

　　epoll的事件注册函数。 epfd是epoll的句柄，即epoll_create的返回值； op表示动作：用三个宏表示： EPOLL_CTL_ADD：注册新的fd到epfd中； EPOLL_CTL_MOD：修改已经注册的fd的监听事件； EPOLL_CTL_DEL：从epfd中删除一个fd； fd是需要监听的套接字描述符； 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：只监听一次事件，当监听完这次事件之后，就会把这个fd从epoll的队列中删除。 
如果还需要继续监听这个socket的话，需要再次把这个fd加入到EPOLL队列里

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

　　等待事件的产生，返回需要处理的事件的数量，并将需处理事件的套接字集合于参数events内，可以遍历events来处理事件。

　　参数epfd为epoll句柄 events为事件集合 参数timeout是超时时间（毫秒，0会立即返回，-1是永久阻塞）。

　　该函数返回需要处理的事件数目，如返回0表示已超时。

　　4.使用实例

 #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 <string.h>

 #define MAXLINE 10   //最大长度
 #define OPEN_MAX 100
 #define LISTENQ 20
 #define SERV_PORT 8000
 #define INFTIM 1000
 #define IP_ADDR "10.73.219.151"

 int main()
 {
     struct epoll_event ev, events[];
     struct sockaddr_in clientaddr, serveraddr;
     int epfd;
     int listenfd;//监听fd
     int maxi;
     int nfds;
     int i;
     int sock_fd, conn_fd;
     char buf[MAXLINE];

     epfd = epoll_create();//生成epoll句柄
     listenfd = socket(AF_INET, SOCK_STREAM, );//创建套接字
     ev.data.fd = listenfd;//设置与要处理事件相关的文件描述符
     ev.events = EPOLLIN;//设置要处理的事件类型

     epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);//注册epoll事件

     memset(&serveraddr, , sizeof(serveraddr));
     serveraddr.sin_family = AF_INET;
     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
     serveraddr.sin_port = htons(SERV_PORT);
     bind(listenfd,(struct sockaddr*)&serveraddr, sizeof(serveraddr));//绑定套接口
     socklen_t clilen;
     listen(listenfd, LISTENQ);//转为监听套接字
     int n;
     while()
     {
         nfds = epoll_wait(epfd,events,,);//等待事件发生
         //处理所发生的所有事件
         for(i=;i<nfds;i++)
         {
             if(events[i].data.fd == listenfd)//有新的连接
             {
                 clilen = sizeof(struct sockaddr_in);
                 conn_fd = accept(listenfd, (struct sockaddr*)&clientaddr, &clilen);
                 printf("accept a new client : %s\n",inet_ntoa(clientaddr.sin_addr));
                 ev.data.fd = conn_fd;
                 ev.events = EPOLLIN;//设置监听事件为可写
                 epoll_ctl(epfd, EPOLL_CTL_ADD, conn_fd, &ev);//新增套接字
             }
             else if(events[i].events & EPOLLIN)//可读事件
             {
                 if((sock_fd = events[i].data.fd) < )
                     continue;
                 if((n = recv(sock_fd, buf, MAXLINE, )) < )
                 {
                     if(errno == ECONNRESET)
                     {
                         close(sock_fd);
                         events[i].data.fd = -;
                     }
                     else
                     {
                         printf("readline error\n");
                     }
                 }
                 else if(n == )
                 {
                     close(sock_fd);
                     printf("关闭\n");
                     events[i].data.fd = -;
                 }

                 printf("%d -- > %s\n",sock_fd, buf);
                 ev.data.fd = sock_fd;
                 ev.events = EPOLLOUT;
                 epoll_ctl(epfd,EPOLL_CTL_MOD,sock_fd,&ev);//修改监听事件为可读
             }

             else if(events[i].events & EPOLLOUT)//可写事件
             {
                 sock_fd = events[i].data.fd;
                 printf("OUT\n");
                 scanf("%s",buf);
                 send(sock_fd, buf, MAXLINE, );

                 ev.data.fd = sock_fd;
                 ev.events = EPOLLIN;
                 epoll_ctl(epfd, EPOLL_CTL_MOD,sock_fd, &ev);
             }
         }
     }

     return ;
 }