深入剖析select、poll、epoll

分手后的思念是犯贱 2022-05-27 03:56 177阅读 0赞

# 1、基本概念 #

IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：  
　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。  
　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。  
　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。  
　　（4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。  
　　（5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。  
　　与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

# 2、select #

**1、首先看看select对应的系统调用。**

/*
    告诉内核一些信息：关心的描述符表，每一个描述符我们关心的条件（读，写，异常），愿意等多久。
    内核返回一些信息：已经准备号描述符的总数量，各个条件下已经准备就绪的描述符。
    
    __nfds：最大文件描述符编号值加1，也可以指定为FD_SETSIZE。指定最大内核可以在有效范围内搜索，这样select效率就更加高点。
    __readfds：指向测试 读描述符集 指针
    __writefds：指向测试 写描述符集 指针
    __exceptfds：指向测试 异常描述符集 指针，某个套接字带外数据到达。
    这三个参数都是值-结果形式，传入告诉内核测试哪些描述符，返回内核告诉你哪些描述符已经准备就绪，所以返回要再次使用select就必须重新设置。
    __timeout：控制着select的阻塞行为。
            __timeout==NULL，select永远等待描述符就绪
            __timeout.tv_sec == 0 &&__timeout.tv_usec == 0根本不等待，测试指定描述符集合并立即返回。
            __timeout.tv_sec != 0 || __timeout.tv_usec != 0等待指定秒及微妙，当指定描述符之一准备好或者指定时间值超时立即返回。
    中间三个参数可以全部位NULL，表示不关心任何条件，此时提供比sleep更加精确的定时器。
    
    返回值：
      -1：表示出错，例如描述符全部没准备好，捕捉到信号。
      0：表示没有描述符准备好。指定描述符一个没有好且超时，这时候返回，描述符集全部清0。需要重新设定。
      正值：说明已经由描述符准备好，值表示3个集合中处于就绪态fd的个数。如果同一个描述符测试读和写，那么计数两次。这样3个描述符集中仍旧打开的位对应于已准备好的描述符。    
    */
    int select (int __nfds, fd_set *__restrict __readfds,
               fd_set *__restrict __writefds,
               fd_set *__restrict __exceptfds,
               struct timeval *__restrict __timeout);
    
    #define FD_SET(fd, fdsetp)//将fd添加到fdset所指向的集合 
    #define FD_CLR(fd, fdsetp)//将fd从fdset所指向的集合移除 
    #define FD_ISSET(fd, fdsetp)//测试fdset集合中的fd描述符是否就绪，
    #define FD_ZERO(fdsetp)//将执行集合初始化为0
    //这四个宏定义用于设置fd_set对应的位。

该函数准许进程指示内核等待多个事件中的任何一个发送，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒。函数原型如下：

#include <sys/select.h>
    #include <sys/time.h>
    int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout)

返回值：就绪描述符的数目，超时返回0，出错返回-1  
函数参数介绍如下：

（1）第一个参数maxfdp1指定待测试的描述字个数，它的值是待测试的最大描述字加1（因此把该参数命名为maxfdp1），描述字0、1、2…maxfdp1-1均将被测试。因为文件描述符是从0开始的。

（2）中间的三个参数readset、writeset和exceptset指定我们要让内核测试读、写和异常条件的描述字。如果对某一个的条件不感兴趣，就可以把它设为空指针。struct fd\_set可以理解为一个集合，这个集合中存放的是文件描述符，可通过以下四个宏进行设置：

//首先创建fd_set变量，然后添加fd，然后注册。 
    void FD_ZERO(fd_set *fdset);           //清空集合
    void FD_SET(int fd, fd_set *fdset);   //将一个给定的文件描述符加入集合之中
    void FD_CLR(int fd, fd_set *fdset);   //将一个给定的文件描述符从集合中删除
    int FD_ISSET(int fd, fd_set *fdset);   // 检查集合中指定的文件描述符是否可以读写

（3）timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。

struct timeval{
                long tv_sec;   //seconds
                long tv_usec;  //microseconds
    };

这个参数有三种可能：  
（1）永远等待下去：仅在有一个描述字准备好I/O时才返回。为此，把该参数设置为空指针NULL。  
（2）等待一段固定时间：在有一个描述字准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。  
（3）根本不等待：检查描述字后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器值必须为0。

**2、工作原理**  
![这里写图片描述][70]

**3、select内核实现**  
Linux 2.6.25中的select系统调用主要有4个函数, 层层分工明确:  
sys\_select：处理时间参数，调用core\_sys\_select。  
core\_sys\_select：处理三个fd\_set参数，调用do\_select。  
do\_select：做select/poll的工作。在合适的时机把自己挂起等待，调用sock\_poll。  
sock\_poll：用函数指针分派到具体的协议层函数tcp\_poll、udp\_poll、datagram\_poll。

/* sys_select(fs/select.c) 处理了超时值（如果有）,将struct timeval转换成了时钟周期数,调用core_sys_select,然后检查剩余时间,处理时间 */   
    asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,    
             fd_set __user *exp, struct timeval __user *tvp)    
    {    
     s64 timeout = -1;    
     struct timeval tv;    
     int ret;    
    
     if (tvp) {
       /*如果有超时值*/   
      if (copy_from_user(&tv, tvp, sizeof(tv)))    
       return -EFAULT;//拷贝失败则返回错误地址码 
    
      if (tv.tv_sec < 0 || tv.tv_usec < 0)/*时间无效*/   
       return -EINVAL;//无效参数 
    
      /* Cast to u64 to make GCC stop complaining */   
      if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)    
       timeout = -1; /* 无限等待*/   
      else {    
       timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);    
       timeout += tv.tv_sec * HZ;/*计算出超时的相对时间,单位为时钟周期数*/   
      }    
     }    
    
     /*主要工作都在core_sys_select中做了*/   
     ret = core_sys_select(n, inp, outp, exp, &timeout);    
    
     if (tvp) {
       /*如果有超时值*/   
      struct timeval rtv;    
    
      if (current->personality & STICKY_TIMEOUTS)/*模拟bug的一个机制,不详细描述*/   
       goto sticky;    
      /*rtv中是剩余的时间*/   
      rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));    
      rtv.tv_sec = timeout;    
      if (timeval_compare(&rtv, &tv) >= 0)/*如果core_sys_select超时返回,更新时间*/   
       rtv = tv;    
      /*拷贝更新后的时间到用户空间*/   
      if (copy_to_user(tvp, &rtv, sizeof(rtv))) {    
    sticky:    
       /* * If an application puts its timeval in read-only * memory, we don't want the Linux-specific update to * the timeval to cause a fault after the select has * completed successfully. However, because we're not * updating the timeval, we can't restart the system * call. */   
       if (ret == -ERESTARTNOHAND)/*ERESTARTNOHAND表明,被中断的系统调用*/   
        ret = -EINTR;//被中断的系统调用 
      }    
     }    
    
     return ret;    
    }

/*core_sys_select 为do_select准备好了位图,然后调用do_select,将返回的结果集,返回到用户空间 */   
    static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,    
             fd_set __user *exp, s64 *timeout)    
    {    
     fd_set_bits fds;    
     void *bits;    
     int ret, max_fds;    
     unsigned int size;    
     struct fdtable *fdt;    
     /* Allocate small arguments on the stack to save memory and be faster */   
    
     /*SELECT_STACK_ALLOC 定义为256*/   
     long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];    
    
     ret = -EINVAL;    
     if (n < 0)    
      goto out_nofds;    
    
     /* max_fds can increase, so grab it once to avoid race */   
     rcu_read_lock();    
     fdt = files_fdtable(current->files);/*获取当前进程的文件描述符表*/   
     max_fds = fdt->max_fds; //获取最大文件描述符表 
     rcu_read_unlock();    
     if (n > max_fds)/*修正用户传入的第一个参数：fd_set中文件描述符的最大值*/   
      n = max_fds;    
    
     /* * We need 6 bitmaps (in/out/ex for both incoming and outgoing), * since we used fdset we need to allocate memory in units of * long-words. */   
    
     /* 如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。 然后将位图平均分成份,并初始化fds结构 */   
     size = FDS_BYTES(n);    
     bits = stack_fds;    
     if (size > sizeof(stack_fds) / 6) {    
      /* Not enough space in on-stack array; must use kmalloc */   
      ret = -ENOMEM;    
      bits = kmalloc(6 * size, GFP_KERNEL);    
      if (!bits)    
       goto out_nofds;    
     }    
     fds.in      = bits;    
     fds.out     = bits +   size;    
     fds.ex      = bits + 2*size;    
     fds.res_in  = bits + 3*size;    
     fds.res_out = bits + 4*size;    
     fds.res_ex  = bits + 5*size;    
    
     /*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/   
     if ((ret = get_fd_set(n, inp, fds.in)) ||    
      (ret = get_fd_set(n, outp, fds.out)) ||    
      (ret = get_fd_set(n, exp, fds.ex)))    
      goto out;//通过copy_from_user将三个描述符集合从用户空间拷贝到内核空间 
    
     zero_fd_set(n, fds.res_in);    
     zero_fd_set(n, fds.res_out);    
     zero_fd_set(n, fds.res_ex);    
    
    
     /* 接力棒传给了do_select */   
     ret = do_select(n, &fds, timeout);    
    
     if (ret < 0)    
      goto out;    
    
     /*do_select返回,是一种异常状态*/   
     if (!ret) {    
      /*记得上面的sys_select不？将ERESTARTNOHAND转换成了EINTR并返回。EINTR表明系统调用被中断*/   
      ret = -ERESTARTNOHAND;    
      if (signal_pending(current))/*当当前进程有信号要处理时,signal_pending返回真,这符合了EINTR的语义*/   
       goto out;    
      ret = 0;    
     }    
    
     /*把结果集,拷贝回用户空间*/   
     if (set_fd_set(n, inp, fds.res_in) ||    
      set_fd_set(n, outp, fds.res_out) ||    
      set_fd_set(n, exp, fds.res_ex))    
      ret = -EFAULT;    
    
    out:    
     if (bits != stack_fds)    
      kfree(bits);/*对应上面的kmalloc*/   
    out_nofds:    
     return ret;    
    }

/*do_select 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数 */   
    int do_select(int n, fd_set_bits *fds, s64 *timeout)    
    {    
     struct poll_wqueues table;    
     poll_table *wait;    
     int retval, i;    
    
     rcu_read_lock();    
     /*根据已经打开fd的位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd*/   
     retval = max_select_fd(n, fds);    
     rcu_read_unlock();    
    
     if (retval < 0)    
      return retval;    
     n = retval;    
    
    
     /*将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait*/   
     poll_initwait(&table);    
     wait = &table.pt;    
    
     if (!*timeout)    
      wait = NULL;    
     retval = 0;    
    
     for (;;) {
       /*死循环*/   
      unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;    
      long __timeout;    
    
      /*注意:可中断的睡眠状态*/   
      set_current_state(TASK_INTERRUPTIBLE);    
    
      inp = fds->in; outp = fds->out; exp = fds->ex;    
      rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;    
    
    
      for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
       /*遍历所有fd*/   
       unsigned long in, out, ex, all_bits, bit = 1, mask, j;    
       unsigned long res_in = 0, res_out = 0, res_ex = 0;    
       const struct file_operations *f_op = NULL;    
       struct file *file = NULL;    
    
       in = *inp++; out = *outp++; ex = *exp++;    
       all_bits = in | out | ex;    
       if (all_bits == 0) {    
        /* __NFDBITS定义为(8 * sizeof(unsigned long)),即long的位数。 因为一个long代表了__NFDBITS位，所以跳到下一个位图i要增加__NFDBITS */   
        i += __NFDBITS;    
        continue;    
       }    
    
       for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {    
        int fput_needed;    
        if (i >= n)    
         break;    
    
        /*测试每一位*/   
        if (!(bit & all_bits))    
         continue;    
    
        /*得到file结构指针，并增加引用计数字段f_count*/   
        file = fget_light(i, &fput_needed);    
        if (file) {    
         f_op = file->f_op;    
         mask = DEFAULT_POLLMASK;    
    
         /*对于socket描述符,f_op->poll对应的函数是sock_poll 注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行*/   
         if (f_op && f_op->poll)    
          mask = (*f_op->poll)(file, retval ? NULL : wait);    
    
         /*释放file结构指针，实际就是减小他的一个引用计数字段f_count*/   
         fput_light(file, fput_needed);    
    
         /*根据poll的结果设置状态,要返回select出来的fd数目，所以retval++。 注意：retval是in out ex三个集合的总和*/   
         if ((mask & POLLIN_SET) && (in & bit)) {    
          res_in |= bit;    
          retval++;    
         }    
         if ((mask & POLLOUT_SET) && (out & bit)) {    
          res_out |= bit;    
          retval++;    
         }    
         if ((mask & POLLEX_SET) && (ex & bit)) {    
          res_ex |= bit;    
          retval++;    
         }    
        }    
    
        /* 注意前面的set_current_state(TASK_INTERRUPTIBLE); 因为已经进入TASK_INTERRUPTIBLE状态,所以cond_resched回调度其他进程来运行， 这里的目的纯粹是为了增加一个抢占点。被抢占后，由等待队列机制唤醒。 在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），cond_resched是空操作 */     
        cond_resched();    
       }    
       /*根据poll的结果写回到输出位图里*/   
       if (res_in)    
        *rinp = res_in;    
       if (res_out)    
        *routp = res_out;    
       if (res_ex)    
        *rexp = res_ex;    
      }    
      wait = NULL;    
      if (retval || !*timeout || signal_pending(current))/*signal_pending前面说过了*/   
       break;    
      if(table.error) {    
       retval = table.error;    
       break;    
      }    
    
      if (*timeout < 0) {    
       /*无限等待*/   
       __timeout = MAX_SCHEDULE_TIMEOUT;    
      } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {    
       /* 时间超过MAX_SCHEDULE_TIMEOUT,即schedule_timeout允许的最大值，用一个循环来不断减少超时值*/   
       __timeout = MAX_SCHEDULE_TIMEOUT - 1;    
       *timeout -= __timeout;    
      } else {    
       /*等待一段时间*/   
       __timeout = *timeout;    
       *timeout = 0;    
      }    
    
      /*TASK_INTERRUPTIBLE状态下，调用schedule_timeout的进程会在收到信号后重新得到调度的机会， 即schedule_timeout返回,并返回剩余的时钟周期数 */   
      __timeout = schedule_timeout(__timeout);    
      if (*timeout >= 0)    
       *timeout += __timeout;    
     }    
    
     /*设置为运行状态*/   
     __set_current_state(TASK_RUNNING);    
     /*清理等待队列*/   
     poll_freewait(&table);    
    
     return retval;    
    }    
    
    
    static unsigned int sock_poll(struct file *file, poll_table *wait)    
    {    
     struct socket *sock;    
    
     /*约定socket的file->private_data字段放着对应的socket结构指针*/   
     sock = file->private_data;    
    
     /*对应了三个协议的函数tcp_poll,udp_poll,datagram_poll，其中udp_poll几乎直接调用了datagram_poll 累了，先休息一下，这三个函数以后分析*/   
     return sock->ops->poll(file, sock, wait);    
    }

（1）使用copy\_from\_user从用户空间拷贝fd\_set到内核空间

（2）注册回调函数\_\_pollwait

（3）遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock\_poll，sock\_poll根据情况会调用到tcp\_poll,udp\_poll或者datagram\_poll）

（4）以tcp\_poll为例，其核心实现就是\_\_pollwait，也就是上面注册的回调函数。

（5）\_\_pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp\_poll来说，其等待队列是sk->sk\_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了。

（6）poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd\_set赋值。

（7）如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule\_timeout是调用select的进程（也就是current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule\_timeout指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd。

（8）把fd\_set从内核空间拷贝到用户空间。

**4、测试程序**

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <sys/select.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #include <assert.h>
    
    #define IPADDR "127.0.0.1"
    #define PORT 8787
    #define MAXLINE 1024
    #define LISTENQ 5
    #define SIZE 10
    
    typedef struct server_context_st
    {
        int cli_cnt;        /*客户端个数*/
        int clifds[SIZE];   /*客户端的个数*/
        fd_set allfds;      /*句柄集合*/
        int maxfd;          /*句柄最大值*/
    } server_context_st;
    static server_context_st *s_srv_ctx = NULL;
    /*=========================================================================== * ==========================================================================*/
    static int create_server_proc(const char* ip,int port)
    {
        int  fd;
        struct sockaddr_in servaddr;
        fd = socket(AF_INET, SOCK_STREAM,0);
        if (fd == -1) {
            fprintf(stderr, "create socket fail,erron:%d,reason:%s\n",
                    errno, strerror(errno));
            return -1;
        }
    
        /*一个端口释放后会等待两分钟之后才能再被使用，SO_REUSEADDR是让端口释放后立即就可以被再次使用。*/
        int reuse = 1;
        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) {
            return -1;
        }
    
        bzero(&servaddr,sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        inet_pton(AF_INET,ip,&servaddr.sin_addr);
        servaddr.sin_port = htons(port);
    
        if (bind(fd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1) {
            perror("bind error: ");
            return -1;
        }
    
        listen(fd,LISTENQ);
    
        return fd;
    }
    
    static int accept_client_proc(int srvfd)
    {
        struct sockaddr_in cliaddr;
        socklen_t cliaddrlen;
        cliaddrlen = sizeof(cliaddr);
        int clifd = -1;
    
        printf("accpet clint proc is called.\n");
    
    ACCEPT:
        clifd = accept(srvfd,(struct sockaddr*)&cliaddr,&cliaddrlen);
    
        if (clifd == -1) {
            if (errno == EINTR) {
                goto ACCEPT;
            } else {
                fprintf(stderr, "accept fail,error:%s\n", strerror(errno));
                return -1;
            }
        }
    
        fprintf(stdout, "accept a new client: %s:%d\n",
                inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
    
        //将新的连接描述符添加到数组中
        int i = 0;
        for (i = 0; i < SIZE; i++) {
            if (s_srv_ctx->clifds[i] < 0) {
                s_srv_ctx->clifds[i] = clifd;
                s_srv_ctx->cli_cnt++;
                break;
            }
        }
    
        if (i == SIZE) {
            fprintf(stderr,"too many clients.\n");
            return -1;
        }
    101 }
    
    static int handle_client_msg(int fd, char *buf) 
    {
        assert(buf);
        printf("recv buf is :%s\n", buf);
        write(fd, buf, strlen(buf) +1);
        return 0;
    }
    
    static void recv_client_msg(fd_set *readfds)
    {
        int i = 0, n = 0;
        int clifd;
        char buf[MAXLINE] = {
       0};
        for (i = 0;i <= s_srv_ctx->cli_cnt;i++) {
            clifd = s_srv_ctx->clifds[i];
            if (clifd < 0) {
                continue;
            }
            /*判断客户端套接字是否有数据*/
            if (FD_ISSET(clifd, readfds)) {
                //接收客户端发送的信息
                n = read(clifd, buf, MAXLINE);
                if (n <= 0) {
                    /*n==0表示读取完成，客户都关闭套接字*/
                    FD_CLR(clifd, &s_srv_ctx->allfds);
                    close(clifd);
                    s_srv_ctx->clifds[i] = -1;
                    continue;
                }
                handle_client_msg(clifd, buf);
            }
        }
    }
    static void handle_client_proc(int srvfd)
    {
        int  clifd = -1;
        int  retval = 0;
        fd_set *readfds = &s_srv_ctx->allfds;
        struct timeval tv;
        int i = 0;
    
        while (1) {
            /*每次调用select前都要重新设置文件描述符和时间，因为事件发生后，文件描述符和时间都被内核修改啦*/
            FD_ZERO(readfds);
            /*添加监听套接字*/
            FD_SET(srvfd, readfds);
            s_srv_ctx->maxfd = srvfd;
    
            tv.tv_sec = 30;
            tv.tv_usec = 0;
            /*添加客户端套接字*/
            for (i = 0; i < s_srv_ctx->cli_cnt; i++) {
                clifd = s_srv_ctx->clifds[i];
                /*去除无效的客户端句柄*/
                if (clifd != -1) {
                    FD_SET(clifd, readfds);
                }
                s_srv_ctx->maxfd = (clifd > s_srv_ctx->maxfd ? clifd : s_srv_ctx->maxfd);
            }
    
            /*开始轮询接收处理服务端和客户端套接字*/
            retval = select(s_srv_ctx->maxfd + 1, readfds, NULL, NULL, &tv);
            if (retval == -1) {
                fprintf(stderr, "select error:%s.\n", strerror(errno));
                return;
            }
            if (retval == 0) {
                fprintf(stdout, "select is timeout.\n");
                continue;
            }
            if (FD_ISSET(srvfd, readfds)) {
                /*监听客户端请求*/
                accept_client_proc(srvfd);
            } else {
                /*接受处理客户端消息*/
                recv_client_msg(readfds);
            }
        }
    }
    
    static void server_uninit()
    {
        if (s_srv_ctx) {
            free(s_srv_ctx);
            s_srv_ctx = NULL;
        }
    }
    
    static int server_init()
    {
        s_srv_ctx = (server_context_st *)malloc(sizeof(server_context_st));
        if (s_srv_ctx == NULL) {
            return -1;
        }
    
        memset(s_srv_ctx, 0, sizeof(server_context_st));
    
        int i = 0;
        for (;i < SIZE; i++) {
            s_srv_ctx->clifds[i] = -1;
        }
    
        return 0;
    }
    
    int main(int argc,char *argv[])
    {
        int  srvfd;
        /*初始化服务端context*/
        if (server_init() < 0) {
            return -1;
        }
        /*创建服务,开始监听客户端请求*/
        srvfd = create_server_proc(IPADDR, PORT);
        if (srvfd < 0) {
            fprintf(stderr, "socket create or bind fail.\n");
            goto err;
        }
        /*开始接收并处理客户端请求*/
        handle_client_proc(srvfd);
        server_uninit();
        return 0;
    err:
        server_uninit();
        return -1;
    }

#include <netinet/in.h>
    #include <sys/socket.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <sys/select.h>
    #include <time.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <errno.h>
    
    #define MAXLINE 1024
    #define IPADDRESS "127.0.0.1"
    #define SERV_PORT 8787
    
    #define max(a,b) (a > b) ? a : b
    
    static void handle_recv_msg(int sockfd, char *buf) 
    {
    printf("client recv msg is:%s\n", buf);
    sleep(5);
    write(sockfd, buf, strlen(buf) +1);
    }
    
    static void handle_connection(int sockfd)
    {
    char sendline[MAXLINE],recvline[MAXLINE];
    int maxfdp,stdineof;
    fd_set readfds;
    int n;
    struct timeval tv;
    int retval = 0;
    
    while (1) {
    
    FD_ZERO(&readfds);
    FD_SET(sockfd,&readfds);
    maxfdp = sockfd;
    
    tv.tv_sec = 5;
    tv.tv_usec = 0;
    
    retval = select(maxfdp+1,&readfds,NULL,NULL,&tv);
    
    if (retval == -1) {
    return ;
    }
    
    if (retval == 0) {
    printf("client timeout.\n");
    continue;
    }
    
    if (FD_ISSET(sockfd, &readfds)) {
    n = read(sockfd,recvline,MAXLINE);
    if (n <= 0) {
    fprintf(stderr,"client: server is closed.\n");
    close(sockfd);
    FD_CLR(sockfd,&readfds);
    return;
    }
    
    handle_recv_msg(sockfd, recvline);
    }
    }
    }
    
    int main(int argc,char *argv[])
    {
    int sockfd;
    struct sockaddr_in servaddr;
    
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
    
    int retval = 0;
    retval = connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
    if (retval < 0) {
    fprintf(stderr, "connect fail,error:%s\n", strerror(errno));
    return -1;
    }
    
    printf("client send to server .\n");
    write(sockfd, "hello server", 32);
    
    handle_connection(sockfd);
    
    return 0;
    }

![这里写图片描述][70 1]

**5、select的几大缺点：**  
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大。  
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，并且将结果从内核态拷贝到用户态，用户态再进行遍历测试，是否满足条件。这个开销在fd很多时也很大，这就是值-结果传递的影响。  
（3）由于内核对fd\_set在线修改，导致应用程序下次调用select前不得不重置3个fd\_set集合，重新来前面的第一步。  
（4）select支持的文件描述符数量太小了，默认是1024，不能处理更多的类型事件。

**6、对于socket，select就绪条件**

套接字可读：  
a）该套接字接收缓冲区中有足够的数据字节数，这是最正常的返回。

b）该连接的读半部关闭( 也就是客户端关闭，服务器端接收了FIN的TCP连接 ）。  
对这样的套接字的读操作将不阻到塞并返回o ( 也就是返回EOF ) 。对方发送了FIN，read返回0（EOF），则可以关闭socket。

c）该套接字是一个监听套接字且已完成的连接数不为0。对这样的套接字的 accept通常不会阻塞。这个暂时不清楚。

d）其上有一个套接字错误待处理。对这样的套接字的读操作将不阻塞并返回-1(也就是返  
回一个错误码)。同时把errno设置成确切的错误条件。

套接字可写：

套接字异常：

![这里写图片描述][70 2]

# 3、poll #

poll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd\_set结构，其他的都差不多。  
poll的机制与select类似，与select在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。**poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。**

**1、poll系统调用**  
函数格式如下所示：

#include <poll.h>
    int poll ( struct pollfd * fds, unsigned int nfds, int timeout);

pollfd结构体定义如下：

struct pollfd {
    int fd;         /* 文件描述符 */
    short events;         /* 等待的事件 */
    short revents;       /* 实际发生了的事件 */
    } ;

每一个pollfd结构体指定了一个被监视的文件描述符，可以传递多个结构体，指示poll()监视多个文件描述符。每个结构体的events域是监视该文件描述符的事件掩码，由用户来设置这个域。revents域是文件描述符的操作结果事件掩码，内核在调用返回时设置这个域。events域中请求的任何事件都可能在revents域中返回。合法的事件如下：

POLLIN 　　　　　　　有数据可读。
    　　POLLRDNORM 　　　　  有普通数据可读。
    　　POLLRDBAND　　　　　 有优先数据可读。
    　　POLLPRI　　　　　　　有紧迫数据可读。
    　　POLLOUT　　　　　　      写数据不会导致阻塞。
    　　POLLWRNORM　　　　　  写普通数据不会导致阻塞。
    　　POLLWRBAND　　　　　   写优先数据不会导致阻塞。
    　　POLLMSGSIGPOLL 　　　　消息可用。
    　　此外，revents域中还可能返回下列事件：
    　　POLLER　　   指定的文件描述符发生错误。
    　　POLLHUP　　 指定的文件描述符挂起事件。
    　　POLLNVAL　　指定的文件描述符非法。

这些事件在events域中无意义，因为它们在合适的时候总是会从revents中返回。

使用poll()和select()不一样，你不需要显式地请求异常情况报告。  
　　POLLIN | POLLPRI等价于select()的读事件，POLLOUT |POLLWRBAND等价于select()的写事件。POLLIN等价于POLLRDNORM |POLLRDBAND，而POLLOUT则等价于POLLWRNORM。例如，要同时监视一个文件描述符是否可读和可写，我们可以设置 events为POLLIN |POLLOUT。在poll返回时，我们可以检查revents中的标志，对应于文件描述符请求的events结构体。如果POLLIN事件被设置，则文件描述符可以被读取而不阻塞。如果POLLOUT被设置，则文件描述符可以写入而不导致阻塞。这些标志并不是互斥的：它们可能被同时设置，表示这个文件描述符的读取和写入操作都会正常返回而不阻塞。  
　　timeout参数指定等待的毫秒数，无论I/O是否准备好，poll都会返回。timeout指定为负数值表示无限超时，使poll()一直挂起直到一个指定事件发生；timeout为0指示poll调用立即返回并列出准备好I/O的文件描述符，但并不等待其它的事件。这种情况下，poll()就像它的名字那样，一旦选举出来，立即返回。  
　　返回值和错误代码  
　　成功时，poll()返回结构体中revents域不为0的文件描述符个数；如果在超时前没有任何事件发生，poll()返回0；失败时，poll()返回-1，并设置errno为下列值之一：  
　　EBADF　　 一个或多个结构体中指定的文件描述符无效。  
　　EFAULTfds　　 指针指向的地址超出进程的地址空间。  
　　EINTR　　　　 请求的事件之前产生一个信号，调用可以重新发起。  
　　EINVALnfds　　参数超出PLIMIT\_NOFILE值。  
　　ENOMEM　　 可用内存不足，无法完成请求。  
**2、poll相比于select**  
（1）通过结构体将文件描述符和事件都定义其中，任何事件都被统一处理，从而使得编程接口更加简单。  
（2）通用含有内核空间都用户空间的数据拷贝，内核仅仅修改pollfd里面的revent成员，而event成员保持不变，因此下次调用poll时，无需重置pollfd类型事件集参数。将值和返回结果分开了。每次poll和select调用都返回整个用户注册的事件集合（包括就绪和未就绪的），所以应用程序索引就绪文件描述符的事件复杂度是O（n）。

**3、例子**  
服务端：

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <errno.h>
    
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <poll.h>
    #include <unistd.h>
    #include <sys/types.h>
    
    #define IPADDRESS "127.0.0.1"
    #define PORT 8787
    #define MAXLINE 1024
    #define LISTENQ 5
    #define OPEN_MAX 1000
    #define INFTIM -1
    
    //函数声明
    //创建套接字并进行绑定
    static int socket_bind(const char* ip,int port);
    //IO多路复用poll
    static void do_poll(int listenfd);
    //处理多个连接
    static void handle_connection(struct pollfd *connfds,int num);
    
    int main(int argc,char *argv[])
    {
        int  listenfd,connfd,sockfd;
        struct sockaddr_in cliaddr;
        socklen_t cliaddrlen;
        listenfd = socket_bind(IPADDRESS,PORT);
        listen(listenfd,LISTENQ);
        do_poll(listenfd);
        return 0;
    }
    
    static int socket_bind(const char* ip,int port)
    {
        int  listenfd;
        struct sockaddr_in servaddr;
        listenfd = socket(AF_INET,SOCK_STREAM,0);
        if (listenfd == -1)
        {
            perror("socket error:");
            exit(1);
        }
        bzero(&servaddr,sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        inet_pton(AF_INET,ip,&servaddr.sin_addr);
        servaddr.sin_port = htons(port);
        if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
        {
            perror("bind error: ");
            exit(1);
        }
        return listenfd;
    }
    
    static void do_poll(int listenfd)
    {
        int  connfd,sockfd;
        struct sockaddr_in cliaddr;
        socklen_t cliaddrlen;
        struct pollfd clientfds[OPEN_MAX];
        int maxi;
        int i;
        int nready;
        //添加监听描述符
        clientfds[0].fd = listenfd;
        clientfds[0].events = POLLIN;
        //初始化客户连接描述符
        for (i = 1;i < OPEN_MAX;i++)
            clientfds[i].fd = -1;
        maxi = 0;
        //循环处理
        for ( ; ; )
        {
            //获取可用描述符的个数
            nready = poll(clientfds,maxi+1,INFTIM);//简化了重置事件集参数。
            if (nready == -1)
            {
                perror("poll error:");
                exit(1);
            }
            //测试监听描述符是否准备好
            if (clientfds[0].revents & POLLIN)
            {
                cliaddrlen = sizeof(cliaddr);
                //接受新的连接
                if ((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen)) == -1)
                {
                    if (errno == EINTR)
                        continue;
                    else
                    {
                       perror("accept error:");
                       exit(1);
                    }
                }
                fprintf(stdout,"accept a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
                //将新的连接描述符添加到数组中
                for (i = 1;i < OPEN_MAX;i++)
                {
                    if (clientfds[i].fd < 0)
                    {
                        clientfds[i].fd = connfd;
                        break;
                    }
                }
                if (i == OPEN_MAX)
                {
                    fprintf(stderr,"too many clients.\n");
                    exit(1);
                }
                //将新的描述符添加到读描述符集合中
                clientfds[i].events = POLLIN;//下次直接poll它
                //记录客户连接套接字的个数
                maxi = (i > maxi ? i : maxi);
                if (--nready <= 0)
                    continue;
            }
            //处理客户连接
            handle_connection(clientfds,maxi);//查看前面的连接是否已经可读。
        }
    }
    
    static void handle_connection(struct pollfd *connfds,int num)
    {
        int i,n;
        char buf[MAXLINE];
        memset(buf,0,MAXLINE);
        for (i = 1;i <= num;i++)
        {
            if (connfds[i].fd < 0)
                continue;
            //测试客户描述符是否准备好
            if (connfds[i].revents & POLLIN)
            {
                //接收客户端发送的信息
                n = read(connfds[i].fd,buf,MAXLINE);
                if (n == 0)
                {
                    close(connfds[i].fd);
                    connfds[i].fd = -1;
                    continue;
                }
               // printf("read msg is: ");
                write(STDOUT_FILENO,buf,n);
                //向客户端发送buf
                write(connfds[i].fd,buf,n);
            }
        }
    }

客户端：

#include <netinet/in.h>
    #include <sys/socket.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <poll.h>
    #include <time.h>
    #include <unistd.h>
    #include <sys/types.h>
    
    #define MAXLINE 1024
    #define IPADDRESS "127.0.0.1"
    #define SERV_PORT 8787
    
    #define max(a,b) (a > b) ? a : b
    
    static void handle_connection(int sockfd);
    
    int main(int argc,char *argv[])
    {
        int                 sockfd;
        struct sockaddr_in  servaddr;
        sockfd = socket(AF_INET,SOCK_STREAM,0);
        bzero(&servaddr,sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(SERV_PORT);
        inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
        connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
        //处理连接描述符
        handle_connection(sockfd);
        return 0;
    }
    
    static void handle_connection(int sockfd)
    {
        char    sendline[MAXLINE],recvline[MAXLINE];
        int     maxfdp,stdineof;
        struct pollfd pfds[2];
        int n;
        //添加连接描述符
        pfds[0].fd = sockfd;
        pfds[0].events = POLLIN;
        //添加标准输入描述符
        pfds[1].fd = STDIN_FILENO;
        pfds[1].events = POLLIN;
        for (; ;)
        {
            poll(pfds,2,-1);
            if (pfds[0].revents & POLLIN)
            {
                n = read(sockfd,recvline,MAXLINE);
                if (n == 0)
                {
                        fprintf(stderr,"client: server is closed.\n");
                        close(sockfd);
                }
                write(STDOUT_FILENO,recvline,n);
            }
            //测试标准输入是否准备好
            if (pfds[1].revents & POLLIN)
            {
                n = read(STDIN_FILENO,sendline,MAXLINE);
                if (n  == 0)
                {
                    shutdown(sockfd,SHUT_WR);
            continue;
                }
                write(sockfd,sendline,n);
            }
        }
    }

# epoll #

首先看看epoll的系统调用。

/* size:指定通过epoll实例来检查的文件描述符个数。参数并不是一个上限，而是告诉内核应该如何为内部数据结构划分初始化大小。 返回值：返回epoll实例的文件描述符。当此文件描述符不需要应该close。 */
    int epoll_create (int __size) __THROW;
    
    
    /* 修改文件描述符epfd所代表的epoll实例中的兴趣列表。 __epfd： __op：指定执行的操作 #define EPOLL_CTL_ADD 1//将fd添加到epfd，对于fd感兴趣的事件都定义在event中 #define EPOLL_CTL_DEL 2//从epfd中删除fd，忽略event参数，关闭fd，描述符自动移除 #define EPOLL_CTL_MOD 3 //修改fd对应感兴趣的事件 __fd：文件描述符 __event：对应感兴趣事件描述及个人数据（个人数据将在epoll_wait中返回），个人数据通常存放文件描述符。 返回：0成功，-1失败。并将errno设置为？？？，可供程序检查 */
    typedef union epoll_data
    {
      void *ptr;
      int fd;
      uint32_t u32;
      uint64_t u64;
    } epoll_data_t;
    struct epoll_event//指定fd对应的感兴趣事件
    {
      uint32_t events;  /* Epoll events */
      epoll_data_t data;    /* User data variable */
    } __EPOLL_PACKED;
    extern int epoll_ctl (int __epfd, int __op, int __fd,
                  struct epoll_event *__event) __THROW;
    
    /* 返回epfd实例中处于就绪态的文件描述符信息。 __epfd：epfd实例文件描述符。 __events：每个元素返回有关就绪态文件描述符信息，由调用函数分配内存。__events[]应该为数组，内部events成员返回发生事件掩码，data成员返回的是在epoll_ctl注册感兴趣事件时候__event.data所指定的值。data字段是唯一可获知事件文件描述符的途径，所以ev.data.fd设为文件描述符，或者将ev.data.ptr设为包含文件描述符的结构体。 __maxevents：指针上面数组元素个数。 __timeout：确定epoll阻塞行为。 -1：一直阻塞，直到感兴趣列表事件发生或捕捉一个信号 0：执行依次非阻塞检查，并立即返回 >0:最多阻塞这个值。 返回值：成功返回__events数组中元素个数。出错返回1，超时没有就绪则为0。 */
    int epoll_wait (int __epfd, struct epoll_event *__events,
                   int __maxevents, int __timeout);

从上面可以看出：

**epoll优点：**

1、epoll的解决方案在`epoll_ctl`函数中。每次注册新的事件到epoll句柄中时（在epoll\_ctl中指定`EPOLL_CTL_ADD`），会把所需要的fd拷贝进内核，而不是在epoll\_wait的时候重复拷贝，epoll保证了每个fd在整个过程中只会拷贝一次。在`EPOLL_CTL_ADD`的时候拷贝进内核，表示这个FD需要监听，最终结果返回在一个数组种。而select每次都需要将FD重新拷贝进内核一次。

2、epoll内部就绪事件，不是通过遍历的，而是通过回调函数实现，所以很快。

3、epoll文件描述符的限制，它所支持的FD上限是最大可以打开文件的数目

4、epoll\_wait进返回就绪就绪事件（填充在对应的数组中），而不是和select一样，返回之后还要去一个一个测试，这个是不是就绪了，减少了系统消耗。  
![这里写图片描述][70 3]

**epoll优点支持两种事件触发模式：水平和边沿触发**  
![这里写图片描述][70 4]  
对于这两种模式：在数据的读和写上面有点差别。  
这里全部描述为非阻塞SOCK，在并发服务器上面阻塞几乎不会使用。  
\*\*对于LT模式，\*\*sock可读，则直接读取数据即可不必读完，如果返回小于等于0，则发生错误，直接关闭sock。  
\*\*对于ET模式，\*\*sock可读，则直接读取数据，在while里面读取，返回0，则sock被对方关闭，服务器直接关闭sock；返回EWOULDBLOCK，则数据读完了，可以结束；返回其他错误则非法，直接关闭sock。  
**对于写监控：**时时刻刻监控sock写是耗费资源的，因为通常滑动窗口足够大，这样会导致每次返回可写，最好在write返回EWOULDBLOCK后，将数据加入队列，然后将sock加入epoll，在写成功之后，将sock移除epoll，避免资源的浪费。

#include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <fcntl.h>
    #include <stdlib.h>
    #include <sys/epoll.h>
    #include <pthread.h>
    
    #define MAX_EVENT_NUMBER 1024
    #define BUFFER_SIZE 10
    
    int setnonblocking( int fd )
    {
        int old_option = fcntl( fd, F_GETFL );
        int new_option = old_option | O_NONBLOCK;
        fcntl( fd, F_SETFL, new_option );
        return old_option;
    }
    
    void addfd( int epollfd, int fd, bool enable_et )
    {
        epoll_event event;
        event.data.fd = fd;//传入文件描述符
        event.events = EPOLLIN;//监听读
        if( enable_et )//文件描述通过ET监听
        {
            event.events |= EPOLLET;//加入ET即可
        }
        epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );//添加事件
        setnonblocking( fd );//设定为非阻塞
    }
    
    void lt( epoll_event* events, int number, int epollfd, int listenfd )
    {
        char buf[ BUFFER_SIZE ];
        for ( int i = 0; i < number; i++ )
        {
            int sockfd = events[i].data.fd;
            if ( sockfd == listenfd )//listenfd就绪，就是证明有新的连接，然后需要加入进来
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof( client_address );
                int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );//返回最新的队列。
                addfd( epollfd, connfd, false );//将connfd套接字加入epoll使用LT模式，这是一个客户连接的描述符
            }
            //只要socket还有数据，下次还是会被重复触发。
            else if ( events[i].events & EPOLLIN )//如果有数据到来
            {
                printf( "event trigger once\n" );
                memset( buf, '\0', BUFFER_SIZE );
                int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );//读数据
                if( ret <= 0 )
                {
                    close( sockfd );//并关闭sockfd
                    continue;
                }
                printf( "get %d bytes of content: %s\n", ret, buf );
            }
            else
            {
                printf( "something else happened \n" );
            }
        }
    }
    
    void et( epoll_event* events, int number, int epollfd, int listenfd )
    {
        char buf[ BUFFER_SIZE ];
        for ( int i = 0; i < number; i++ )
        {
            int sockfd = events[i].data.fd;
            if ( sockfd == listenfd )
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof( client_address );
                int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
                addfd( epollfd, connfd, true );//加入，通过ET模式
            }
            else if ( events[i].events & EPOLLIN )
            {
                //这段代码不会被重复触发，所以必须将数据读完。
                printf( "event trigger once\n" );
                while( 1 )
                {
                    memset( buf, '\0', BUFFER_SIZE );
                    int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
                    if( ret < 0 )
                    {
                        if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
                        {
                            printf( "read later\n" );
                            break;
                        }
                        close( sockfd );
                        break;
                    }
                    else if( ret == 0 )
                    {
                        close( sockfd );
                    }
                    else
                    {
                        printf( "get %d bytes of content: %s\n", ret, buf );
                    }
                }
            }
            else
            {
                printf( "something else happened \n" );
            }
        }
    }
    
    int main( int argc, char* argv[] )
    {
        if( argc <= 2 )
        {
            printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
            return 1;
        }
        const char* ip = argv[1];
        int port = atoi( argv[2] );
    
        int ret = 0;
        struct sockaddr_in address;
        bzero( &address, sizeof( address ) );
        address.sin_family = AF_INET;
        inet_pton( AF_INET, ip, &address.sin_addr );
        address.sin_port = htons( port );
    
        int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
        assert( listenfd >= 0 );
    
        ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
        assert( ret != -1 );
    
        ret = listen( listenfd, 5 );
        assert( ret != -1 );
    
        epoll_event events[ MAX_EVENT_NUMBER ];
    
        int epollfd = epoll_create( 5 );
        assert( epollfd != -1 );
    
        addfd( epollfd, listenfd, true );//将listenfd加入epoll
    
        while( 1 )
        {
            int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );//一直阻塞，直到事件就绪
            if ( ret < 0 )
            {
                printf( "epoll failure\n" );
                break;
            }
    
            lt( events, ret, epollfd, listenfd );
            //et( events, ret, epollfd, listenfd );
        }
    
        close( listenfd );
        return 0;
    }

# 比较三组IO复用函数 #

![这里写图片描述][70 5]

[70]: /images/20220527/89af31a973724215bf831429855d78cc.png
[70 1]: /images/20220527/b620e92dfd694f29a3b325cf5da4c1df.png
[70 2]: /images/20220527/baf3927477954810bdc09e55e2dc9507.png
[70 3]: /images/20220527/00b7378613a740ecba83326e009e54b2.png
[70 4]: /images/20220527/77e62fa4eefe452a95ead56b83dfbbdf.png
[70 5]: /images/20220527/1e016560e41b4e728b68d5b00bf75a71.png