网络 IO - 多路复用技术 select,poll,epoll

select,poll,epoll 都是 IO 多路复用的机制,I/O 多路复用就是通过一种机制,一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作。但 select,poll,epoll本质上都是同步 I/O,因为他们都需要在读写时间就绪后自己负责进行读写,也就是说这个读写过程是阻塞的,而异步 I/O 则无需自己负责进行读写,异步 I/O 的实现会负责把数据从内核拷贝到用户空间。

为什么需要 IO 多路复用

除了 IO 多路复用,同步的网络 IO 还有其他模型,比如阻塞和非阻塞。这两种都能处理网络 IO,那么为什么会需要多路复用这种模式了。

如果使用同步 IO 模式,现在一个进程需要等待网卡的数据,也需要等待键盘的数据,为了同时监听这两个设备,我们就需要开两个进程或者两个线程,设备数不多的情况下这样没有问题,但是假如现在有一万个设备,那么开一万个线程代价就很大了。所以其实这一万个线程都是阻塞着的,他们只是等待设备准备就绪后开始处理。所以人们设想如果让一个线程监听所有的设备,这样就可以大大减少开销。所以多路复用的方式就产生了,假设 A 进程来监听所有的设备,那么业务线程只需要告诉 A 线程自己想监听哪些设备,然后留一个线程来等待 A 的返回就好了,不过业务需要监听多少个设备,监听这一块就只需要一个 A 和一个等待 A 结果的线程。这样就实现了一个线程监听所有的设备的思路。也就是多路复用的思路。

select

select 的方法签名如下

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
  • nfds
    是后面三类监听的 fd 中的最大值的那个描述符加 1。这个值主要用来说明需要监听的文件描述符的范围,这个范围必须覆盖所有集合中的文件描述符。
    比如读集合是 [0,2,4], 写集合是 [5],异常集合为空,所以这个 nfds 就是 5+1 = 6,所以 select 的监听范围是 0,1,2,3,4,5,虽然实际并不需要监听 3,但是 select 的机制是这样处理的。

  • readfds,writefds,exceptfds
    分别是读集合,写集合,异常集合。
    三个集合分别表示三类 fd,监听读,监听写和错误。返回值是已经就绪的描述符的数目。

  • timeout
    设置阻塞超时时间
    如果设置为 NULL,select 就会一直阻塞直到信号中断或者描述符就绪。
    设置了超时后,一旦超时就会立即返回,返回结果为 0。

select 原理

  1. 调用后 select 时传入所有需要监听的描述符,然后函数会阻塞。
  2. 阻塞直到有描述符就绪(有数据可读,可写,或者有 except),或者超时(timeout 指定等待时间,如果立即返回设为 null 即可)
  3. 当有描述符就绪时,select 会从 fdset 集合里去掉所有非就绪的描述符,只留下已经就绪的,然后函数返回。
  4. 当 select 函数返回后,可以通过遍历 fdset 来找到就绪的描述符。

代码示例

while(1){
    // 清空描述符集合
    FD_ZERO(&rset);
    // 重新设置描述符
      for (i = 0; i< 5; i++ ) {
          FD_SET(fds[i],&rset);
      }

       puts("round again");
    // 执行 select,写集合和异常集合为空。
    select(max+1, &rset, NULL, NULL, NULL);

    // select 返回后,查看在 rset 中的描述符,有就表示就绪了。然后执行对应逻辑。
    for(i=0;i<5;i++) {
        if (FD_ISSET(fds[i], &rset)){
            memset(buffer,0,MAXBUF);
            read(fds[i], buffer, MAXBUF);
            puts(buffer);
        }
    }    
  }

select 监听的文件描述符限制

[图片来自 https://blog.csdn.net/xuefeng0707/article/details/23390509]

select 存储 fd_set 是用的类似 bitmap 的形式,一个 long 型的数组,数组元素个数是 1024 / sizeof(long),所以是每一个 bit 位表示一个 fd,这个数组限制了最大就 1024 个 bit 位。

select 目前几乎在所有的平台上支持,其良好的跨平台支持也是它的一个优点。select 的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制,在 Linux 上一般为1024,可以通过修改宏定义甚至重新编译内核的方式提升这一限制,但是这样会造成效率降低。

select 的实现方式是遍历被传入的所有文件描述符,所以会随着文件描述符的增加导致性能下降。

poll

poll 的函数签名如下

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

不同于 select 使用三个位掩码来表示三个 fdset 的方式,poll 使用一个 pollfd 的指针实现。

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

pollfd 结构包含了要监视的 event 和发生的 event,不在使用 select “参数-值”的传递方式。

poll 方式为每个需要监听的文件描述符构建一个类型为 pollfd 的对象并填充监听的事件,poll 返回后,检查 revents 字段判断是否就绪。poll 不会修改 pollfds 数组,所以不需要每次都重新传入 pollfds,但是每次处理完需要重制 revents 值。

同时,pollfd 并没有最大数量限制(但是数量过大后性能也是会下降)。和 select 函数一样,poll 返回后,需要轮询 pollfd 来获取就绪的描述符。

select 和 poll 都需要在返回后,通过遍历文件描述符来获取已经就绪的 socket。事实上,同时连接的大量客户端在某一时刻可能只有很少的处于就绪状态,因此随着监视的描述符数量的增长,效率也会线性下降。

poll 代码示例

 for (i=0;i<5;i++) 
  {
    memset(&client, 0, sizeof (client));
    addrlen = sizeof(client);
    pollfds[i].fd = accept(sockfd,(struct sockaddr*)&client, &addrlen);
    pollfds[i].events = POLLIN;
  }
  sleep(1);
  while(1){
      puts("round again");
    poll(pollfds, 5, 50000);

    for(i=0;i<5;i++) {
        if (pollfds[i].revents & POLLIN){
            pollfds[i].revents = 0;
            memset(buffer,0,MAXBUF);
            read(pollfds[i].fd, buffer, MAXBUF);
            puts(buffer);
        }
    }
  }

select vs poll

  • select 的文件描述符集合大小是固定的。
  • select 描述符集合会在返回时重建,所以每次后续调用需要重新初始化。
  • select 内部使用位掩码记录文件描述符,如果传入的最大文件描述符是 900,内核将检查传入集合的每个值得每一位,直到第 900 位。
  • select 平台支持性更好。

epoll

epoll 是在内核的 2.6 版本中提出的,是之前的 select 和 poll 的增强版本。相对于 select 和 poll 来说,epoll 更加灵活,没有描述符限制。epoll 使用一个文件描述符管理多个描述符,将用户关心的文件描述符的时间存放到内核的一个时间表中,这样在用户空间和内核空间的复制只需要一次。

同时,select 和 poll 在添加或者删除监听的文件描述符时需要修改集合并重新调用 select/poll。epoll 也不需要了。

一、epoll 操作过程

epoll 操作过程需要三个接口,分别如下:

// 创建一个 epoll 的句柄,size 用来告诉内核这个监听的数目一共有多大
int epoll_create(int size); 
// 向  epfd 里添加、移除文件描述符
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 
// 等待事件发生
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
int epoll_create(int size)

创建一个 epoll 的句柄,size 用来告诉内核这个监听的数目一共多大,这个参数不同于 select() 中的第一个参数,给出最大监听的 fd+1 的值,参数 size 并不是限制了 epoll 所能监听的描述符的最大个数,只是对内核初始分配内部数据结构的一个建议
当创建好 epoll 句柄后,它就会占用一个 fd 值,在 linux 下如果查看 /proc/进程id/fd,是能够看到这个 fd 的,所以在使用完 epoll 后,必须调用 close() 关闭,否则可能导致 fd 被耗尽。

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

函数是对指定描述符 fd 执行 op 操作。

  • epfd: 是 epoll_create() 的返回值。
  • op: 表示 op 操作,用三个宏来表示,
    添加 EPOLL_CTL_ADD,
    删除 EPOLL_CTL_DEL,
    修改 EPOLL_CTL_MOD。
    分别添加,删除和修改对 fd 的监听事件。
  • fd:是需要监听的 fd(文件描述符)
  • epoll_event:是告诉内核需要监听什么事件,struct epoll_event 的结构如下:
    ```c
    struct epoll_event {
    __uint32_t events; / Epoll events /
    epoll_data_t data; / User data variable /
    };

// events 可以是一下几个宏的集合
// EPOLLIN: 表示对应的文件描述符可以读(包括对端 socket 正常关闭);
// EPOLLOUT:表示对应的文件描述符可以写;
// EPOLLPRI:表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来);
// EOPLLERR:表示对应的文件描述符发生错误;
// EPOLLHUB:表示对应的文件描述符被挂断;
// EPOLLET:将 EPOLL 设为边远触发,这是相对于水平触发来说的;
// EPOLLONESHOT:只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个 socket 的话,需要再次把这个 socket 假如到 EPOLL 队列里

###### int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)
等待 epfd 上的 io 事件,最多返回 maxevents 个事件。
参数 events 用来从内核得到事件的集合,maxevents 告知内核这个 events 有多大,这个 maxevents 的值不能大于创建 epoll_create() 的 size,参数 timeout 是超时时间(毫秒,0 会立即返回,-1 将不确定,也有说法是永久阻塞)。该函数返回需要处理的时间数目,如返回 0 表示已超时。

##### epoll 代码示例
```c
 struct epoll_event events[5];
  int epfd = epoll_create(10);
  ...
  ...
  for (i=0;i<5;i++) 
  {
    static struct epoll_event ev;
    memset(&client, 0, sizeof (client));
    addrlen = sizeof(client);
    ev.data.fd = accept(sockfd,(struct sockaddr*)&client, &addrlen);
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, ev.data.fd, &ev); 
  }

  while(1){
      puts("round again");
      nfds = epoll_wait(epfd, events, 5, 10000);

    for(i=0;i<nfds;i++) {
            memset(buffer,0,MAXBUF);
            read(events[i].data.fd, buffer, MAXBUF);
            puts(buffer);
    }
  }
二、工作模式

epoll 对文件描述符的操作有两种模式:LT(水平触发 level trigger) 和 ET(边缘触发 edge trigger)。LT 模式为默认模式,LT 模式与 ET 模式的区别如下:

LT模式:当 epoll_wait 检测到描述符时间发生并将此事件通知应用程序,应用程序可以不立即处理该时间。下次调用 epoll_wait 时,会再次相应应用程序并通知此事件。

ET模式:当 epoll_wait 检测到描述符事件发生并将此事件通知应用程序,应用程序必须立即处理该事件。如果不处理,下次调用 epoll_wait 时,不会再次响应应用程序并通知次事件。

LT 模式

LT(level triggered) 是默认的工作方式,并且同时支持阻塞和非阻塞模型的 socket。在这种做法中,内核告诉进程一个文件描述符是否就绪了,然后进程就可以对这个就绪的 fd 进行 IO 操作。如果进程不做任何操作,内核还是会继续通知进程。

ET 模式

ET(edge-triggered) 是高速工作方式,只支持非阻塞模型的 socket。在这种模式下,当描述符从未就绪变为就绪时,内核通过 epoll 告诉进程。然后它会认为进程知道文件描述符已经就绪,并且不会再为那个文件描述符发送更多的这次就绪的通知,直到进程做了某些操作导致那个文件描述符不再为就绪状态了(比如发送或者接收请求,或者发送接收的数据少于一定量时导致了一个 EWOULDBLOCK 错误)后再次就绪。但是注意,如果一直不对这个就绪的 fd 做 IO 操作(从而导致它再次变回未就绪),内核就不会发送更多的通知(only once)。

ET 模式在很大程度上减少了 epoll 时间被重复触发的次数,因此效率要比 LT 模式高。

epoll 工作在 ET 模式的时候,必须使用非阻塞 IO 的 socket。因为 ET 模式中,每次得到 epoll_wait() 的返回后,必须把这个 fd 缓冲区的数据全部读完,即用 while 的方式循环读,直到返回 EAGAIN。如果是阻塞 socket,那么读完后的那一次调用就会阻塞住,如果一直没有新的数据可读就会一直阻塞,从而影响 fd 的处理。另一方面,如果缓冲区有 1kb 的空间,想写入 2kb,那么写完 1kb 的时候就阻塞住了,

总结

假如有这样一个例子:

  1. 我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到 epoll 描述符
  2. 这个时候从管道的另一端写入了 2KB 的数据
  3. 调用 epoll_wait(2),并且它会返回 RFD,说明它已经准备好读取操作。
  4. 然后我们读取了 1KB 的数据
  5. 调用 epoll_wait(2) ……

LT模式
如果是 LT 模式,那么在第 5 步调用 epoll_wait(2) 后,仍然能收到通知。

ET模式
如果在第 1 步将 RFD 添加到 epoll 描述符的时候使用了 EPOLLET 标志,那么在第 5 步调用 epoll_wait(2) 之后有可能会挂起,因为剩余的数据还存在于文件的输入缓冲区内,而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第 5 步的时候,调用者可能会放弃等待仍存在于文件输入缓冲区内的剩余数据。

当使用 epoll 的 ET 模型来工作时,当产生了一个 EPOLLIN 事件后,读数据的时候需要考虑的是当 recv() 返回的大小如果等于请求的大小,那么很可能是缓冲区还有数据未读完,也意味着该次事件还没有处理完,所以还需要再次读取:

while(rs) {
    buflen = recv(activeevents[i].data.df, sizeof(buf), 0);
    if (buflen < 0){
        // 由于是非阻塞模式,所以当 errno 为 EAGAIN 时,表示当前缓冲区已无数据可读
        // 在这里就当做是该次事件已经处理完。
        if (errno = EAGAIN) {
            break;
        }else{
            return;
        }
    }else if(buflen == 0){
        //  这里表示对端的 socket 已正常关闭
    }

    if (buflen == sizeof(buf) {
        rs = 1; // 需要再次读取
    }else{
        re = 0;
    }
}

Linux 中的 EAGAIN 含义
Linux 环境下开发经常会碰到很多错误(errno),其中 EAGAIN 是比较常见的一个错误(比如用在非阻塞操作中)。从字面上来看是提醒再试一次,这个错误经常出现在当应用程序进行一些非阻塞操作的时候。
例如,以 O_NONBLOCK 的标志打开文件 /socket/FIFO,如果连续做 read 操作而没有数据可读。此时程序不会阻塞起来等待数据准备就绪返回,read 函数会返回一个错误 EAGAIN,提示你的应用程序现在没有数据可读请稍后再试。又比如,当一个系统调用(比如 fork)因为没有足够的资源(比如虚拟内存)而执行失败,返回 EAGAIN 提示其在调用一次(也许下次就能成功)。

三、代码演示

下面的伪代码,主要用来描述过程

#define IPADDRESS "127.0.0.1"
#define PORT     8787
#define MAXSIXE  1024
#define LISTENQ  5
#define FDSIZE   1000
#define EPOLLEVENTS 100

listenfd = socket_bind(IPADDRESS, PORT);

struct epoll_event events[EPOLLEVENTS];

// 创建一个描述符
epollfd = epoll_create(FDSIZE);

// 添加及监听的描述符事件
add_event(epollfd, listenfd, EPOLLIN);

// 循环等待
for (; ;){
    // 该函数返回已经准备好的描述符事件数目
    res = epoll_wait(epollfd, events, EPOLLEVENTS, -1)
    // 处理手接收到的连接
    handle_events(epollfd, events, ret, listenfd, buf);
}

// 事件处理
static void handle_events(int epollfd, struct epoll_event * events, int num, int listenfd, char *buf){
    int i;
    int fd;
    for (i=0;i<num; i++){
        fd = events[i].data.fd;
        // 根据描述符的类型和事件类型进行处理
        if ((fd == listenfd) && (events[i].events & EPOLLIN)){
            handler_accept(epollfd, listenfd);
        }else if(events[i].events & EPOLLIN){
            do_read(epollfd, fd, buf);
        }else if(events[i].events & EPOLLOUT){
            do_write(epollfd, fd, buf);
        }
    }
}

// 处理接收到的连接
static void handle_accept(int epollfd, int listenfd){
    int clifd;
    struct sockaddr_in_cliaddr:
    socklen_t cliaddrlen;
    clifd = accept(listenfd, (struct sockaddr*)&cliaddr, &cliadrlen);

    if (clifd == -1){
        perror("accept error: ")
    }else{
        printf("accept a new client")
        add_event(epollfd, clifd, EPOLIN);
    }
}

// 读处理
static void do_read(int epollfd, int fd, char *buf){
    int nread;
    nread = read(fd, buf, MAXSIZE);
    if (nread == -1){
        perror("read error");
        close(fd);
        delete_event(epollfd, fd, EPOLLIN); // 删除监听
    }else if (nread == 0){
        fprintf(stderr, "client close.\n");
        close(fd);
        delete_event(epollfd, fd, EPOLLIN);
    }else{
        printf("read message: %s\n",buf);
        modify_event(epollfd, fd, EPOLLOUT);
    }
}

// 写处理
static void do_write(int epollfd, int fd, char *buf){
    int nwrite;
    nwrite = write(fd, buf, strlen(buf));
    if (nwrite == -1){
        perror("write error");
        close(fd);
        delete_event(epollfd, fd, EPOLLOUT);
    }else{
        modify_event(epollfd, fd, EPOLLIN);
    }
    memset(buf, 0, MAXSIZE);
}

// 添加事件
static vodi add_event(int epollfd, int fd, int state){
    struct epoll_event ev;
    ev.events = state;
    ev.data.fd = fd;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
}
// 删除和修改事件的代码类似添加
四、epoll 总结

在 select/poll 模式中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而 epoll 实现通过 epoll_ctl() 来注册一个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似 callback 的回调机制,迅速激活这个文件描述符,当季农村调用 epoll_wait() 时便会得到通知。(此处去掉了遍历文件描述符,而是通过监听回调的机制。这正是 epoll 的魅力所在。)

epoll 的优点主要在以下几个方面

  1. 监视的文件描述符不受限制,它所支持的 FD上限是最大可以打开文件的数目,这个数字一般远大于 2048,举个例子,在 1GB 内存的机器上大约是 10万左右,具体数目可以 cat /proc/sys/fs/file-max 查看,一般来说这个数目和系统内存关系很大。select 最大的去掉就是进程打开的 fd 是有数量限制的。这UI大于连接数量比较大的服务器来说根本不能满足。虽然可以选择多进程的解决方案(Apache 就是这样实现的),不过虽然 Linux 上创建进程的代价比较小,但数量巨大时也是不可忽略的,加上进程间数据同步远比不上线程间同步的高效,所以也不是完美的解决方案。

  2. IO 的效率不会随着监视 fd 的数量的增长而下降。epoll 不同于 selec 和 poll 的轮询方式,而是通过每个 fd 定义的回调函数来实现的。只有就绪的 fd 才会执行回调函数。
    如果没有大量的 idel-connection 或者 dead-connection,epoll 的效率并不会比 select/poll 高很多,但是当遇到大量的 idle-connection,就会发现 epoll 的效率大大高于 select/poll。

epoll 和 select/poll 的区别

select 有几个大的缺点

  1. 每次调用 select 都需要把 fd 集合从用户态拷贝到内核态(传参),这个开销在 fd 很多的时候很大。
  2. 每次调用 select 都需要在内核遍历传递进来的所有 fd,这个开销在 fd 很多的时候也很大。
  3. select 支持的文件描述符数量太小了,默认是 1024。

poll 模式和 select 非常相似,只是描述 fd 集合的方式不同。

对于第 1 个缺点,epoll 的解决方案是在 epoll_ctl 函数中,每次注册新的事件到 epoll 句柄中时(在 epoll_ctl 中指定 EPOLL_CTL_ADD),会把所有的 fd 拷贝进内核,而在执行 epoll_wait 的时候就不需要重复拷贝了。

对于第 2 个缺点,epoll 不像 select 一样每次都把当前进程轮流假加入到 fd 对应的设备等待队列中,而只是在 epoll_ctl 时加入一次,然后为每个 fd 指定一个回调函数,当设备就绪,就会调用这个回调函数,而这个回调函数就会把就绪的 fd 加入到一个就绪链表。epoll_wait 的工作实际上就是在这个就绪链表中查看有没有就绪的 fd(利用 schedule_timeout 实现睡一会儿判断一会儿)。

对于第 3 个缺点,epoll 没有限制。它所支持的 fd 上限是最大可以打开的文件数目。

参考
select、poll、epoll之间的区别总结[整理]