一文讲清I/O多路复用（select、poll和epoll）

一、写在前面

本文尽可能使用最简单和最清楚的逻辑对比select、poll和epoll技术之间的区别，说明I/O多路复用从select发展到epoll到底优化了什么。

注意：1、本文不讲解select、poll和epoll三个系统调用的具体参数；2、未有特殊说明则本文以Linux平台作为基础；3、所有讲解仅代表作者本人理解，如有错误烦请指正。

二、概述

网络服务端处理并发连接的最简方案当属多线程设计，而多线程最大的问题就在于CPU上下文切换，且线程的资源占用较多，在高并发情况下多线程设计方案显得非常不合理，所以我们不如从单线程逻辑上进行I/O优化。

这里说明一下，我们刚才所谈及的线程是信号处理线程，这里读者可以简单理解成管理连接的线程（监听文件描述符是否有事件触发），而不是工作线程（及处理数据的线程）。下面是单线程设计伪码：

while(true)
{
    for(fd : fd[n])
    {
        if(fd有事件触发)
        {
            处理fd上的事件
        }
    }
}

单线程的问题在于if判断上，用户态程序为了判断fd是否有事件触发（例如有数据可读或可写）需要切换到内核态，这样以来，每次if判断都要进行用户态到内核态的切换，效率低下，而I/O多路复用技术主要就是对这个缺陷进行优化，它的整体思路便是：如果在用户态监听fd每次判断都要切换到内核态，那么就让内核直接帮我们监听fd，然后把触发的事件一次性返回给我们。

三、select技术

1、概述

在用户态初始化一个bitmap，将需要监听的文件描述符映射到这个bitmap中，把bitmap传入内核，内核监听对应的fd，如果fd有事件触发则对bitmap进行标记，标记完后整个返回到用户态，用户程序通过对bitmap的判断确定需要处理的fd进行处理。

2、流程

1）现有5个文件描述符fd(1~5)分别为：1、3、4、6、7；

2）用户程序创建一个位图rset，将第1位、第3位依次类推至第7位置为1；

3）将rset传入select（下面是select的处理）：

① 将rset拷贝到内核，内核中的位图记为rset1（用户态到内核态，第一次切换）
 
② 内核阻塞（可以设置超时）监听fd(1~5)，有事件发生时，内核通过修改rset1标记事件对应的fd
 
③ 将rset1拷贝回用户态的rset返回（内核态到用户态，第二次切换）

4）select退出，用户程序获得rset，并通过遍历rset确认需要处理的fd及对应的事件；

3、编码

void main()
{
    // ...
    // 已创建服务器socket为sockfd
    listen(sockfd, 5);
    
    int fds[5] = {0};
    int max = 0;
    
    for(int i = 0; i < 5; ++i)
    {
        int fds[i] = accept(sockfd, NULL, NULL);
        if(fds[i] > max)
        {
        	max = fds[i];
        }
    }
    
    fd_set rset;
    char buf[MAXLEN] = {0};
    
    while(true)
    {
        FD_ZERO(&rset);
        for(int i = 0; i < 5; ++i)
        {
            FD_SET(fds[i], &rset);
        }
 
        select(max + 1, &rset, NULL, NULL, NULL);	// 阻塞
 
        for(int i = 0; i < 5; ++i)
        {
            if(FD_ISSET(fds[i], &rset))
            {
                memset(buf, 0, MAXLEN);
                read(fds[i], buf, MAXLEN);	// 事件处理，以读事件为例
                std::cout << buf << "\n";
            }
        }
    }
}

4、问题

1）bitmap大小受限（默认为1024）

2）rset不可重用，每次while开始需要循环初始化rset，时间复杂度O(n)

3）用户态和内核态之间切换

4）用户程序需要循环遍历rset，判断哪个fd上发生了事件，时间复杂度O(n)

四、poll技术

1、概述

struct pollfd
{
	int fd;
	short events;
	short revents;
};

在用户态初始化一个pollfd数组pfds，通过需要监听的fd和事件初始化pfds（修改pollfd结构中的fd和events），把pfds传入内核，内核监听对应的fd，如果有事件触发则修改对应的pollfd的revents，修改完成后返回pollfd数组到用户态，用户态遍历pollfd数组确认需要处理的fd进行处理。

2、流程

1）现有5个文件描述符fd(1~5)；

2）用户程序创建一个长度为5的pollfd数组pfds，使用fd(1~5)和需要监听的事件初始化pfds的fd和events成员；

3）将pfds传入poll（下面是poll的处理）：

① 将pfds拷贝到内核，内核中的pollfd数组记为pfds1（用户态到内核态，第一次切换）
 
② 内核阻塞监听pfds1中的fd，有事件发生时，内核修改pfds1的revents
 
③ 将pfds1拷贝回用户态的pfds返回（内核态到用户态，第二次切换）

4）poll退出，用户程序获得pfds，并通过遍历pfds确认哪些fd有事件发生；

3、编码

void main()
{
    // ...
    struct pollfd pfds[5];
 
    for(int i = 0; i < 5; ++i)
    {
        pfds[i].fd = accept(sockfd, NULL, NULL);
        pfds[i].events = POLLIN;	// 读事件
    }
 
    char buf[MAXLEN] = {0};
 
    while(true)
    {
        poll(pfds, 5, 1000);	// 阻塞，超时时间1000ms
 
        for(int i = 0; i < 5; ++i)
        {
            if(pfds[i].revents & POLLIN)
            {
                pfds[i].revents = 0;
                memset(buf, 0, MAXLEN);
                read(pfds[i].fd, buf, MAXLEN);	// 事件处理，以读事件为例
                std::cout << buf << "\n";
            }
        }
    }
}

4、问题

1）bitmap大小受限（默认为1024）（使用了pollfd数组）

2）rset不可重用，每次while开始需要循环初始化rset，时间复杂度O(n)（pollfd结构因为有revents成员所以可重用）

3）用户态和内核态之间切换

4）用户程序需要循环遍历rset，判断哪个fd上发生了事件，时间复杂度O(n)

五、epoll技术

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_data_t data;
};

用户态通过调用epoll_create函数创建一个epoll实例（底层实现为红黑树，通过文件描述符管理），将被监听fd和事件通过epoll_ctl和epoll_event注册到epoll实例，创建一个epoll_events数组用于接收epoll处理结果，用户态和内核态共享这个epoll_events数组，内核监听对应的fd，当有事件触发时内核对epoll_events数组进行重排，将已经就绪的fd放到靠前位置，然后返回触发事件的fd总数，用户程序拿到返回后直接处理已经发生事件的fd，而不需要遍历所有fd。

水平触发（LT）： 在水平触发模式下，当文件描述符上有事件发生时，epoll_wait会立即返回通知应用程序。如果应用程序没有处理完这个事件，下次调用epoll_wait时仍然会返回这个事件。
边缘触发（ET）： 在边缘触发模式下，epoll_wait只在发生状态变化时才返回通知，而不是在文件描述符上有事件发生时就返回。这意味着应用程序必须一次性处理完这个事件，否则会错过后续的事件通知。

2、流程

1）现有5个文件描述符fd(1~5)；

2）用户程序通过epoll_create调用获取epfd；

3）循环调用epoll_ctl将fd及对应的待监听事件注册到epfd上（以epoll_event作为载体）

4）创建一个epoll_event数组events用于存储触发结果（events由用户态和内核态共享）；

5）将epfd和events通过epoll_wait传入epoll（下面是epoll的处理）：

① 内核阻塞监听注册到epfd上的fd，有事件发生时对events进行重排（分为水平触发和边缘触发）
 
② 内核返回已经触发事件的fd总数

6）epoll退出，用户程序拿到触发事件的fd总数，直接处理已经发生事件events

3、编码

void main()
{
    int epfd = epoll_create(1);
 
    for(int i = 0; i < 5; ++i)
    {
        static struct epoll_event ev;
        ev.data.fd = accept(sockfd, NULL, NULL);
        ev.events = EPOLLIN;	// 读事件
        epoll_ctl(epfd, EPOLL_CTL_ADD, ev.data.fd, &ev);	//注册事件
    }
 
    struct epoll_event events[5];
    char buf[MAXLEN] = {0};
    
    while(true)
    {
        int fds = epoll_wait(epfd, events, 5, 1000);	// 阻塞，超时时间1000ms
 
        for(int i = 0; i < fds; ++i)
        {
            memset(buf, 0, MAXLEN);
            read(events[i].data.fd, buf, MAXLEN);	// 事件处理，以读事件为例
            std::cout << buf << "\n";
        }
    }
}

4、问题

1）bitmap大小受限（默认为1024）

2）rset不可重用，每次while开始需要循环初始化rset，时间复杂度O(n)

3）用户态和内核态之间切换（用户态和内核态共用epoll_events数组）

4）用户程序需要循环遍历rset，判断哪个fd上发生了事件，时间复杂度O(n)（直接返回已经发生事件的fd总数）

5、一个完整的epoll使用示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
#define MAX_EVENTS 10
 
int main() 
{
    int listen_sock, conn_sock, nfds, epollfd;
    struct epoll_event ev, events[MAX_EVENTS];
    struct sockaddr_in serv_addr;
 
    // 创建 socket
    if ((listen_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) 
    {
        perror("socket");
        exit(EXIT_FAILURE);
    }
 
    // 设置服务器地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(8888);
 
    // 绑定 socket
    if (bind(listen_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) 
    {
        perror("bind");
        exit(EXIT_FAILURE);
    }
 
    // 监听 socket
    if (listen(listen_sock, 5) == -1) 
    {
        perror("listen");
        exit(EXIT_FAILURE);
    }
 
    // 创建 epoll 文件描述符
    if ((epollfd = epoll_create1(0)) == -1) 
    {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }
 
    // 设置要监控的事件
    ev.events = EPOLLIN;
    ev.data.fd = listen_sock;
 
    // 将 listen_sock 加入到 epoll 监控列表中
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) 
    {
        perror("epoll_ctl: listen_sock");
        exit(EXIT_FAILURE);
    }
 
    for (;;) 
    {
        // 等待事件的发生
        nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        if (nfds == -1) 
        {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }
 
        // 处理所有发生的事件
        for (int n = 0; n < nfds; ++n) 
        {
            if (events[n].data.fd == listen_sock) 
            {
                // 如果是 listen_sock，表示有新的连接
                if ((conn_sock = accept(listen_sock, NULL, NULL)) == -1) 
                {
                    perror("accept");
                    continue;
                }
                printf("Accepted new connection from client\n");
 
                // 将新的 socket 加入到 epoll 监控列表中
                ev.events = EPOLLIN;
                ev.data.fd = conn_sock;
                if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) 
                {
                    perror("epoll_ctl: conn_sock");
                    close(conn_sock);
                }
            } 
            else 
            {
                // 如果是已连接的 socket，处理读事件
                char buffer[1024];
                int ret = recv(events[n].data.fd, buffer, sizeof(buffer), 0);
                if (ret <= 0) 
                {
                    // 关闭连接
                    close(events[n].data.fd);
                    continue;
                }
                // 处理接收到的数据
                printf("Received data from client: %s\n", buffer);
            }
        }
    }
 
    // 关闭 epoll 文件描述符和 socket
    close(epollfd);
    close(listen_sock);
 
    return 0;
}