网络编程4：高并发服务器——多路I/O转接服务器设计（select、poll、epoll）

返回：Linux网络编程学习笔记

select、poll、epoll三者优缺点对比

多路I/O函数	优点	缺点
select	1.函数诞生时间早，跨平台性好，windows、linux、macOS、Unix、类Unix均支持	1.监听的文件描述符上限为1024；2.需要添加业务逻辑，来监听满足条件的fd，代码编程难度会提高（业务逻辑是指添加一个1024大小的数组，通过数组来管理满足条件的fd，详见代码）
poll	1.自带数组结构，可将监听和返回事件集合分离；2.可以拓展文件描述符监听上限，突破1024	1.不能跨平台，仅Linux支持；2.无法直接定位满足监听事件的文件描述符，编码难度较大
epoll	1.解决了监听事件难于管理的问题，编程比较简单；2.监听事件上限可以突破1024	1.不能跨平台，仅Linux支持。

1. select

1.1 select输入参数说明

       /* According to earlier standards */
       #include 
       #include 
       #include 

       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

       void FD_CLR(int fd, fd_set *set);
       int  FD_ISSET(int fd, fd_set *set);
       void FD_SET(int fd, fd_set *set);
       void FD_ZERO(fd_set *set);

参数说明：
int nfds                       //监听的最大文件描述符+1，作为监听循环的上限
fd_set *read_fds,        //监视的可读文件句柄集合。
fd_set *write_fds,       //监视的可写文件句柄集合。
fd_set *excepr_fds,      //监视的异常文件句柄集合。
struct timeval *timeout //本次select()的超时结束时间。

1.2 select函数使用方法

方法一：通过循环判断文件lfd+1到maxfd之间是否有读事件，来操作套接字的读和写。

缺点：效率比较低，在lfd+1到maxfd之间如果有文件关闭了，也会进入FD_ISSET的判断。

方法二：定义数组int client[1024]，用来管理lfd+1到maxfd之间需要监听的文件，具体方法如下：

1.当lfd有读事件时会生成cfd，通过for循环查找靠前没有使用的client元素，使client[i]=cfd（未使用的client[i]会置-1）；

2.在使用FD_ISSET之前，先判断client[i]是否大于0，大于0的情况才进行判断。

具体的操作如下：

参考链接：linux select函数详解

1.3 使用select函数实现多路I/O转发

详见底部代码

主要疑问：select函数实现的是一个非阻塞忙轮询的逻辑，accept函数为何不会阻塞？

原因很简单，下方代码在使用accept函数之前，首先通过FD_ISSET函数判断了listenfd是有读事件发生的，所以不阻塞。只有在listenfd没有读事件且使用accept函数的情况下，才会阻塞，通过条件判断规避了阻塞的情况。

        nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready < 0)
            perr_exit("select error");

        if (FD_ISSET(listenfd, &rset)) {                        /* 说明有新的客户端链接请求 */

            clie_addr_len = sizeof(clie_addr);
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);       /* Accept 不会阻塞 */

            FD_SET(connfd, &allset);                            /* 向监控文件描述符集合allset添加新的文件描述符connfd */

            if (maxfd < connfd)
                maxfd = connfd;

            if (0 == --nready)                                  /* 只有listenfd有事件, 后续的 for 不需执行 */
                continue;
        }

2. poll

2.1 poll函数输入参数说明

NAME
       poll, ppoll - wait for some event on a file descriptor

SYNOPSIS
       #include 

       int poll(struct pollfd *fds, nfds_t nfds, int timeout);

       #define _GNU_SOURCE         /* See feature_test_macros(7) */
       #include 
       #include 

       int ppoll(struct pollfd *fds, nfds_t nfds,
               const struct timespec *tmo_p, const sigset_t *sigmask);

DESCRIPTION
       poll()  performs  a  similar  task to select(2): it waits for one of a set of file descriptors to
       become ready to perform I/O.

       The set of file descriptors to be monitored is specified in the fds argument, which is  an  array
       of structures of the following form:

           struct pollfd {
               int   fd;         /* file descriptor */
               short events;     /* requested events */
               short revents;    /* returned events */
           };

说明：

（1）struct pollfd结构体介绍

struct pollfd {
int fd; //待监听文件描述符
short events; //待监听文件描述符对应的监听事件，可以为POLLIN、POLLOUT、POLLERR ...
short revents; //传入时赋值0。如果满足对应事件返回非0。
};

（2）nfds 监听数组实际的有效监听个数

（3）timeout 超时时长。单位ms（-1 阻塞；0 不阻塞，立即返回；>0 超时时长，单位毫秒）

poll函数返回值：满足对应监听事件的文件描述符总个数。

2.2 poll函数使用方法

poll函数的使用与select类似，使用前需要定义struct pollfd类型结构体，例如监听1024个文件描述符的定义如下：

struct pollfd pfds[1024];

在使用poll函数之前，需要先设置pfds的成员，以监听套接字lfd为例，使用第0号元素结构体pfds[0]来监听lfd，监听的事件为读事件POLLIN，revent置0；

使用poll之后，发现有连接事件出现，就通过accept函数创建连接套接字cfd，并将cfd放进pfds里面进行监听；

如果连接套接字上有读事件发生，就调用read和write进行处理，程序的具体流程如下，代码省略。

3. epoll

3.1 epoll的三把斧

（1）epoll_create

NAME
       epoll_create, epoll_create1 - open an epoll file descriptor

SYNOPSIS
       #include 

       int epoll_create(int size);
       int epoll_create1(int flags);

size：创建红黑树的监听节点数量（仅供内核参考，分配对应大小的资源）

epoll_create返回值：成功返回指向新创建的红黑树根节点的fd；失败返回 -1和errno。

（2）epoll_ctl

NAME
       epoll_ctl - control interface for an epoll file descriptor

SYNOPSIS
       #include 

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

epfd：epoll_create创建的红黑树根节点的文件描述符

op：对应如下三种操作

EPOLL_CTL_ADD：将fd添加到监听红黑树

EPOLL_CTL_MOD：修改fd在监听红黑树上的监听事件

EPOLL_CTL_DEL：将fd从监听红黑树上摘下

fd：待监听的文件描述符

event：传入参数，epoll监听事件结构体，events为返回的监听事件类型（可选EPOLLIN、EPOLLOUT、EPOLLER等），

data为一联合体，其泛参成员ptr可用于构建epoll反应堆模型。

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;

epoll_ctl：成功返回0，失败返回-1和errno。

（3）epoll_wait

NAME
       epoll_wait, epoll_pwait - wait for an I/O event on an epoll file descriptor

SYNOPSIS
       #include 

       int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
       int epoll_pwait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout,
                      const sigset_t *sigmask);

epfd：epoll_create创建的红黑树根节点的文件描述符

events：数组型传出参数，满足监听条件的文件描述符对应的epoll_event结构体

maxevents：数组元素的总个数

timeout：超时时间，-1 阻塞；0 立即返回，不阻塞；>0 单位ms。

epoll_wait返回值：成功返回有多少个文件描述符就绪，时间到返回0，出错返回-1。

3.2 epoll函数的使用方法

epoll函数的编程难度比较简单，分为三步：

第1步创建监听红黑树树根epollfd；

第2步将listen_socket添加到红黑树上；

第3步实施监听，当返回listen_sock读事件时，创建conn_sock，并添加到监听红黑树，当返回conn_sock对应的读事件时，进行服务器与客户端相关的操作。

使用举例：

           #define MAX_EVENTS 10
           struct epoll_event ev, events[MAX_EVENTS];
           int listen_sock, conn_sock, nfds, epollfd;

           /* Code to set up listening socket, 'listen_sock',
              (socket(), bind(), listen()) omitted */

           epollfd = epoll_create1(0);  //第1步创建监听红黑树树根epollfd
           if (epollfd == -1) {
               perror("epoll_create1");
               exit(EXIT_FAILURE);
           }

           ev.events = EPOLLIN;
           ev.data.fd = listen_sock;  //第2步将listen_socket添加到红黑树上
           if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
               perror("epoll_ctl: listen_sock");
               exit(EXIT_FAILURE);
           }

           for (;;) {  //第3步实施监听，当返回listen_sock读事件时，创建conn_sock，并添加到监听红黑树，当返回conn_sock对应的读事件时，进行服务器与客户端相关的操作
               nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
               if (nfds == -1) {
                   perror("epoll_wait");
                   exit(EXIT_FAILURE);
               }

               for (n = 0; n < nfds; ++n) {
                   if (events[n].data.fd == listen_sock) {
                       conn_sock = accept(listen_sock,
                                          (struct sockaddr *) &addr, &addrlen);
                       if (conn_sock == -1) {
                           perror("accept");
                           exit(EXIT_FAILURE);
                       }
                       setnonblocking(conn_sock);
                       ev.events = EPOLLIN | EPOLLET;
                       ev.data.fd = conn_sock;
                       if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
                                   &ev) == -1) {
                           perror("epoll_ctl: conn_sock");
                           exit(EXIT_FAILURE);
                       }
                   } else {
                       do_use_fd(events[n].data.fd);
                   }
               }
           }

4. 程序附件

4.1 使用select方法一实现服务器端

说明：编译时需要添加wrap.h和wrap.c

#include 
#include 
#include 
#include 
#include 
#include 

#include "wrap.h"

#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    int i, j, n, nready;

    int maxfd = 0;

    int listenfd, connfd;

    char buf[BUFSIZ];         /* #define INET_ADDRSTRLEN 16 */

    struct sockaddr_in clie_addr, serv_addr;
    socklen_t clie_addr_len;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family= AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port= htons(SERV_PORT);
    Bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    Listen(listenfd, 128);
    

    fd_set rset, allset;                            /* rset 读事件文件描述符集合 allset用来暂存 */

    maxfd = listenfd;

    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);                                  /* 构造select监控文件描述符集 */

    while (1) {   
        rset = allset;                                          /* 每次循环时都从新设置select监控信号集 */
        nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready < 0)
            perr_exit("select error");

        if (FD_ISSET(listenfd, &rset)) {                        /* 说明有新的客户端链接请求 */

            clie_addr_len = sizeof(clie_addr);
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);       /* Accept 不会阻塞 */

            FD_SET(connfd, &allset);                            /* 向监控文件描述符集合allset添加新的文件描述符connfd */

            if (maxfd < connfd)
                maxfd = connfd;

            if (0 == --nready)                                  /* 只有listenfd有事件, 后续的 for 不需执行 */
                continue;
        } 

        for (i = listenfd+1; i <= maxfd; i++) {                 /* 检测哪个clients 有数据就绪 */

            if (FD_ISSET(i, &rset)) {

                if ((n = Read(i, buf, sizeof(buf))) == 0) {    /* 当client关闭链接时,服务器端也关闭对应链接 */
                    Close(i);
                    FD_CLR(i, &allset);                        /* 解除select对此文件描述符的监控 */

                } else if (n > 0) {

                    for (j = 0; j < n; j++)
                        buf[j] = toupper(buf[j]);
                    Write(i, buf, n);
                }
            }
        }
    }

    Close(listenfd);

    return 0;
}

4.2 使用select方法二实现服务器端

使用client[1024]数组来打理需要监听的文件