select、poll、epoll用法

时间：2022-02-10 19:49:08

我们先从著名的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. 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模式的文件句柄必须是非阻塞的

相关文章