select、poll、epoll用法

我们先从著名的C10K问题开始探讨，由于早期在网络还不普及的时候，互联网的用户并不是很多，一台服务器同时在线100个用户估计在当时已经算是大型应用了。但是随着互联网的发展，用户群体迅速的扩大，每一个用户都必须与服务器保持TCP连接才能进行实时的数据交互。Facebook这样的网站同一时间的并发TCP连接可能会过亿。这时候问题就来了。

解决这种问题的思路主要有两个：一个是对于每一个连接处理分配一个独立的进程或线程；另一种就是用同一进程或线程来同时处理若干个连接。

第一种解决方案，即来一个TCP链接，就需要分配一个进程/线程。而进程又是操作系统最昂贵的资源，一台机器无法创建很多进程，比如C10K问题就要创建1万个进程，操作系统是无法承受的。

第二中解决方案，即每个进程/线程同时处理多个连接(IO多路复用)，我们讨论的select，poll，epoll都是基于这种思路的。

• 这种思路最简单的方法是循环挨个处理各个请求，每个连接对应一个socket，当所有的socket的有数据的时候，这种方法是可行的，但当应用读取某个socket的文件数据不ready的时候，整个应用就会阻塞在这里等待该文件句柄，即使别的文件句柄ready，也无法往下处理。
• select要解决的就是上面的阻塞问题，思路很简单，如果我在读取文件句柄之前，先查看它的状态，ready了就进行处理，不ready就不进行处理，这样就解决了这个问题了
  1. select 使用fd_set结构体来告诉内核同时监控多个文件句柄，当其中有文件句柄的状态发生制定变化或超时，则调用返回。之后使用FD_ISSET来捉个查看是哪个文件句柄发生变化。
  2. fd_set可以理解为一个集合，这个集合中存放的是文件描述符(file descriptor)，即文件句柄，这可以是我们所说的普通意义的文件，当然Unix下任何设备、管道、FIFO等都是文件形式，全部包括在内，所以毫无疑问一个socket就是一个文件，socket句柄就是一个文件描述符。
  3. fd_set集合可以通过一些宏由人为的来操作，FD_ZERO(fd_set*)：清空集合；FD_SET(int, fd_set*)：将指定的文件描述符加入到集合；FD_CLR(int, fd_set*)：将一个给定的文件描述符从集合中删除；FD_ISSET(int, fd_set*)：判断指定的文件描述符是否可以读写。
  4. select函数原型：int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);
     1. maxfdp：集合中所有文件描述符的范围，即所有文件描述符的最大值+1；
     2. readfds：指定我们要监视的读变化的文件描述符集合，即我们是否可以从这些文件中读取数据；
     3. writefds：指定我们要监视的写变化的文件描述符集合，即我们是否可以从这些文件中写数据；
     4. errorfds：用来监视文件错误异常；
     5. timeout：select 的超时时间，若将此参数设为NULL，表示阻塞，直到有文件描述符状态发生变化；若将此参数设为0秒0毫秒，表示非阻塞，直接返回，返回值为0表示没有文 件描述符发生变化，返回值为非0表示有文件描述符发生变化；若将此参数设为大于0，表示等待的时间，期间如果有事件发生则返回非0值，如果一直没有事件， 则等待此参数设置的时间，然后返回0。
  5. select可以实现小规模的连接，但当连接数很多的时候，逐个检查状态就很慢了，因此，select往往存在管理的句柄上限(FD_SETSIZE)，同时，在使用上，因为只有一个字段记录关注和发生事件，每次调用之前要重新初始化fd_set结构体。
  6. select例子：
     1. server.c:

        #include <sys/time.h>
        #include <netinet/in.h>
        #include <sys/select.h>
        #include <sys/types.h>
        #include <sys/socket.h>
        #include <unistd.h>
        #include <stdio.h>
        #include <stdlib.h>
        
        int main(){
            int socket1, socket2;
            struct sockaddr_in socket1addr, socket2addr;
            fd_set fds;
            struct timeval timeout = {, };
            char buffer[] = {};
        
            socket1 = socket(PF_INET, SOCK_DGRAM, );
            //bzero(&socket1addr, sizeof(socket1addr));
            socket1addr.sin_family = AF_INET;
            socket1addr.sin_addr.s_addr = htonl(INADDR_ANY);
            socket1addr.sin_port = htons();
            bind(socket1, (struct sockaddr*)&socket1addr, sizeof(socket1addr));
        
            socket2 = socket(PF_INET, SOCK_DGRAM, );
            //bzero(&socket2addr, sizeof(socket2addr));
            socket2addr.sin_family = AF_INET;
            socket2addr.sin_addr.s_addr = htonl(INADDR_ANY);
            socket2addr.sin_port = htons();
            bind(socket2, (struct sockaddr*)&socket2addr, sizeof(socket2addr));
        
            while(){
                FD_ZERO(&fds);
                FD_SET(socket1, &fds);
                FD_SET(socket2, &fds);
                int maxfdp = (socket1 > socket2) ? (socket1+) : (socket2 + );
                int retval = select(maxfdp, &fds, NULL, NULL, &timeout);
                if(retval == -){
                    printf("error\n");
                    return -;
                }else if(retval == ){
                    continue;
                }else{
                    struct sockaddr_in client;
                    int len = sizeof(client);
                    if(FD_ISSET(socket1, &fds)){
                        recvfrom(socket1, buffer, , , (struct sockaddr*)&client, &len);
                        printf("%u says:%s\n", ntohs(client.sin_port), buffer);
                    }
                    if(FD_ISSET(socket2, &fds)){
                        recvfrom(socket2, buffer, , , (struct sockaddr*)&client, &len);
                        printf("%u says:%s\n", ntohs(client.sin_port), buffer);
                    }
                }
        
            }
        }

     2. client.c

        #include <stdio.h>
        #include <string.h>
        #include <sys/socket.h>
        #include <netinet/in.h>
        
        int main(int argc, char **argv)
        {
            if(argc < ){
                printf("usage: %s port\n", argv[]);
                return -;
            }
            int sockfd;
            struct sockaddr_in servaddr;
        
            sockfd = socket(PF_INET, SOCK_DGRAM, );
        
            bzero(&servaddr, sizeof(servaddr));
            servaddr.sin_family = AF_INET;
            servaddr.sin_port = htons(atoi(argv[]));
            servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
        
            char sendline[];
            sprintf(sendline, "Hello, world!");
        
            sendto(sockfd, sendline, strlen(sendline), , (struct sockaddr *)&servaddr, sizeof(servaddr));
        
            close(sockfd);
        
            return ;
        }

• poll解决了select的两个问题，通过一个pollfd数组向内核传递需要关注的事件消除文件句柄上限，同时使用不同字段分别标注关注事件和发生事件，来避免重复初始化。

　　　　poll函数原型：int poll(struct pollfd[], nfds_t nfds, int timeout);

　　　　　　　　1）struct pollfd的结构如下：

　　　　　　　　　　struct pollfd{

　　　　　　　　　　　　int fd;　　　　//文件描述符

　　　　　　　　　　　　short events;  //请求的事件

　　　　　　　　　　　　short revents; //返回的事件

　　　　　　　　　　};

　　　　　　　　　events和revents是通过对代表各种事件的标志进行逻辑或运算构建而成的。其中events是传入参数，revents是传出参数，即revents的填充是由内核来完成的。

　　　　　　　　　fd代表一个文件描述符，当fd设置为负值时，则忽略events的设置并将revents设置为0，

　　　　　　　　2）nfds：要监视的描述符的个数，即pollfd[]的大小。

　　　　　　　　3）timeout：指定poll在返回前没有接受事件应该等待的事件。INFTIM表示永远等待，0表示立即返回不阻塞进程，>0表示等待指定时间。

　　　　poll函数事件的标识符值：

　　　　　　

常量	说明
POLLIN	普通或优先级带数据可读
POLLRDNORM	普通数据可读
POLLRDBAND	优先级带数据可读
POLLPRI	高优先级数据可读
POLLOUT	普通数据可写
POLLWRNORM	普通数据可写
POLLWRBAND	优先级带数据可写
POLLERR	发生错误
POLLHUP	发生挂起
POLLNVAL	描述字不是一个打开的文件

　　　　poll问题：虽然poll解决了select中的两个问题，但是它仍然需要逐个排查所有文件句柄状态，效率不高。

　　　　poll函数例子：

1. 1. server.c:

       #include <stdio.h>
       #include <netinet/in.h>
       #include <stdlib.h>
       #include <sys/socket.h>
       #include <sys/types.h>
       #include <sys/poll.h>
      
       int main(){
           struct pollfd pollfd[];
           int socket1, socket2;
           struct sockaddr_in socket1addr, socket2addr;
      
           socket1 = socket(PF_INET, SOCK_DGRAM, );
           socket1addr.sin_family = AF_INET;
           socket1addr.sin_addr.s_addr = htonl(INADDR_ANY);
           socket1addr.sin_port = htons();
           bind(socket1, (struct sockaddr*)&socket1addr, sizeof(socket1addr));
      
           socket2 = socket(PF_INET, SOCK_DGRAM, );
           socket2addr.sin_family = AF_INET;
           socket2addr.sin_addr.s_addr = htonl(INADDR_ANY);
           socket2addr.sin_port = htons();
           bind(socket2, (struct sockaddr*)&socket2addr, sizeof(socket2addr));
      
           pollfd[].fd = socket1;
           pollfd[].events = POLLIN;
           pollfd[].fd = socket2;
           pollfd[].events = POLLIN;
      
           while(){
               int numready = poll(pollfd, , -);
               if(numready == -){
                   break;
               }else if(numready == ){
                   continue;
               }else{
                   char buffer[]={};
                   struct sockaddr_in client;
                   int i, len = sizeof(client);
                   for(i=; i< ; i++){
                       if(pollfd[i].revents & POLLIN){
                           recvfrom(pollfd[i].fd, buffer, , , (struct sockaddr*)&client, &len);
                           printf("%d says %s\n", ntohs(client.sin_port), buffer);
                           numready--;
                       }
                   }
               }
           }
           int i;
           for(i=; i<; i++){
               close(pollfd[i].fd);
           }
      
           return ;
       }

   2. client.c:

      #include <stdio.h>
      #include <string.h>
      #include <sys/socket.h>
      #include <netinet/in.h>
      
      int main(int argc, char **argv)
      {
          if(argc < ){
              printf("usage: %s port\n", argv[]);
              return -;
          }
          int sockfd;
          struct sockaddr_in servaddr;
      
          sockfd = socket(PF_INET, SOCK_DGRAM, );
      
          bzero(&servaddr, sizeof(servaddr));
          servaddr.sin_family = AF_INET;
          servaddr.sin_port = htons(atoi(argv[]));
          servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
      
          char sendline[];
          sprintf(sendline, "Hello, world!");
      
          sendto(sockfd, sendline, strlen(sendline), , (struct sockaddr *)&servaddr, sizeof(servaddr));
      
          close(sockfd);
      
          return ;
      }

• epoll

　　　　既然逐个排查所有文件句柄状态效率不高，很自然的，如果调用返回的时候只给应用提供发生了状态变化的文件句柄，这样效率就会高很多，epoll就是采用了这种设计，使用与大规模　　　的应用场景。

　　　　epoll的使用：epoll用到三个函数：epoll_create、epoll_ctl、epoll_wait。

　　　　函数原型：

　　　　　　int epoll_create(int size)

　　　　　　　　该函数生成一个epoll专用的文件描述符(即返回值)，size指定生成描述符的最大范围。

　　　　　　int epoll_ctl(int epfd, int op, int fd, struct epoll_event event)

　　　　　　　　该函数用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。调用成功返回0，失败返回-1。

　　　　　　　　epfd：由epoll_create生成的专用文件描述符

　　　　　　　　op：要进行的操作，可能取值：EPOLL_CTL_ADD(注册)，EPOLL_CTL_MOD(修改)，EPOLL_CTL_DEL(删除)。

　　　　　　　　fd：关联的文件描述符

　　　　　　　　event：指向epoll_event的指针

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

　　　　　　　　该函数用于轮询事件的发生。返回发生的事件数，-1表示有错误。

　　　　　　　　epfd：由epoll_create生成的专用文件描述符

　　　　　　　　epoll_event：用于回传待处理事件的数组

　　　　　　　　maxevents：每次能处理的事件数

　　　　　　　　timeout：等待事件发生的超时值，-1永远等待直到有事件发生。

　　　　数据结构：

　　　　

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

　　　　　　结构体epoll_event 被用于注册所感兴趣的事件和回传所发生待处理的事件，其中epoll_data 联合体用来保存触发事件的某个文件描述符相关的数据，例如一个client连接到服务器，　　　　　　服务器通过调用accept函数可以得到于这个client对应 的socket文件描述符，可以把这文件描述符赋给epoll_data的fd字段以便后面的读写操作在这个文件描述符上进行。　　　　　　　　　　epoll_event 结构体的events字段是表示感兴趣的事件和被触发的事件可能的取值为：

　　　　　　EPOLLIN ：表示对应的文件描述符可以读；
　　　　　　EPOLLOUT：表示对应的文件描述符可以写；
　　　　　　EPOLLPRI：表示对应的文件描述符有紧急的数据可读
　　　　　　EPOLLERR：表示对应的文件描述符发生错误；
　　　　　　EPOLLHUP：表示对应的文件描述符被挂断；
　　　　　　EPOLLET：表示对应的文件描述符设定为edge模式；

　　　　使用例子：

　　　　　　server.c

　　　　　　

#include <stdio.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(){
    struct epoll_event ev1, ev2, events[];
    int epfd = epoll_create();
    int socket1, socket2;
    struct sockaddr_in socket1addr, socket2addr;

    socket1 = socket(PF_INET, SOCK_DGRAM, );
    socket1addr.sin_family = AF_INET;
    socket1addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socket1addr.sin_port = htons();
    bind(socket1, (struct sockaddr*)&socket1addr, sizeof(socket1addr));

    socket2 = socket(PF_INET, SOCK_DGRAM, );
    socket2addr.sin_family = AF_INET;
    socket2addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socket2addr.sin_port = htons();
    bind(socket2, (struct sockaddr*)&socket2addr, sizeof(socket2addr));

    ev1.data.fd = socket1;
    ev1.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, socket1, &ev1);

    ev2.data.fd = socket2;
    ev2.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, socket2, &ev2);

    while(){
        int nfds = epoll_wait(epfd, events, , );
        int i;
        for(i=; i<nfds; i++){
            char buffer[];
            struct sockaddr_in client;
            int len = sizeof(client);
            if((events[i].data.fd == socket1) && (events[i].events&&EPOLLIN)){
                recvfrom(socket1, buffer, , , (struct sockaddr*)&client, &len);
                printf("%u says:%s\n", ntohs(client.sin_port), buffer);
            }else if((events[i].data.fd == socket2) && (events[i].events&&EPOLLIN)){
                recvfrom(socket2, buffer, , , (struct sockaddr*)&client, &len);
                printf("%u says:%s\n", ntohs(client.sin_port), buffer);
            }
        }
    }
}

　　　　　　client.c

　　　　　　

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(int argc, char **argv)
{
    if(argc < ){
        printf("usage: %s port\n", argv[]);
        return -;
    }
    int sockfd;
    struct sockaddr_in servaddr;

    sockfd = socket(PF_INET, SOCK_DGRAM, );

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(atoi(argv[]));
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    char sendline[];
    sprintf(sendline, "Hello, world!");

    sendto(sockfd, sendline, strlen(sendline), , (struct sockaddr *)&servaddr, sizeof(servaddr));

    close(sockfd);

    return ;
}

　　　　Epoll的ET模式与LT模式
　　　　　　ET（Edge Triggered）与LT（Level Triggered）的主要区别可以从下面的例子看出
　　　　　　eg：
　　　　　　　　1． 标示管道读者的文件句柄注册到epoll中；
　　　　　　　　2． 管道写者向管道中写入2KB的数据；
　　　　　　　　
3． 调用epoll_wait可以获得管道读者为已就绪的文件句柄；
　　　　　　　　
4． 管道读者读取1KB的数据
　　　　　　　　
5． 一次epoll_wait调用完成
　　　　　　
如果是ET模式，管道中剩余的1KB被挂起，再次调用epoll_wait，得不到管道读者的文件句柄，除非有新的数据写入管道。如果是LT模式，只要管道中有数据可读，每次调用epoll_wait都会触发。

　　　　　　另一点区别就是设为ET模式的文件句柄必须是非阻塞的