I/O多路复用技术最佳学习实践及总结（含完整实现源码）

文章目录

- - 摘要 -
- 一、select
- - 1.select的基本原理
  - 2.函数原型
  - 3.优点
  - 4.局限性
  - 5.最佳实践
  - 6.代码
- 二、poll
- - 1.poll 的基本原理
  - 2.函数原型
  - - 3.pollfd 结构体
  - 4.poll 的优点
  - 5.poll 的局限性
  - 6.最佳实践
  - 7.代码
- 三、epoll
- - 1.基本原理和特点
  - 2.接口原型
  - - - ① epoll_ctl 接口
      - ②epoll_wait 接口
  - 3.epoll_event 结构体
  - 4.epoll 的优点
  - 5.epoll 的局限性
  - 6.最佳实践
  - 7.代码
- 四、kqueue　［待后续更新］
- 五、io_ring　［待后续更新］
- 六、iocp 　［待后续更新］
- 七、总结
- - 1.横评
  - - - ① select
      - ② poll
      - ③ epoll
      - ④ kqueue
      - ⑤ io_uring
      - ⑥ IOCP (I/O Completion Ports)
  - 2.后论

- 摘要 -

本人测试系统为 CentOS Stream 9 。
文章包含了每种IO多路复用方式的基本原理、函数原型、结构体、优点、局限性、最佳实践建议以及完整代码实现。
文末有对I／O多路复用方案的横向对比。
点赞、收藏、关注，期待更多好文。

一、select

在Linux系统编程中，多路复用是一种允许单个进程监视多个文件描述符以等待一个或多个I/O条件成立的技术。这种技术对于开发高性能的网络服务尤其重要，因为它可以帮助管理多个并发网络连接，而不需要为每个连接分别使用线程或进程。常见的多路复用技术包括select、poll和epoll。

1.select的基本原理

select函数能够监视一组文件描述符，等待其中一个或多个描述符就绪（即，数据可读、可写或出现异常）。在Linux中，select的基本用法涉及设置三种类型的文件描述符集合：可读集、可写集和异常集，以及一个超时值。

2.函数原型

#include <sys/select.h>

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

－参数说明

nfds：被监视的文件描述符的最大值加1。
readfds：一个文件描述符集合，select将检查这些描述符是否准备好读取。
writefds：一个文件描述符集合，select将检查这些描述符是否准备好写入。
exceptfds：一个文件描述符集合，select将检查这些描述符是否有异常条件发生。
timeout：指定等待文件描述符就绪的时间限制。如果设置为NULL，select将无限期等待。

3.优点

简单易用：select的API相对简单，容易理解和使用。
广泛支持：几乎所有的操作系统都支持select。

4.局限性

文件描述符数量限制：select受FD_SETSIZE的限制，这通常是1024，意味着它无法处理超过此数量的连接。
效率问题：select在每次调用时需要重新指定所有的文件描述符和超时信息，这在文件描述符数量较多时会导致性能问题。
可扩展性差：随着监视的文件描述符数量的增加，select的性能通常会线性下降。

5.最佳实践

适用场景：在文件描述符数量较少，且不要求极高性能的情况下使用select。
替代方案：在需要处理大量连接或高性能服务器时，考虑使用epoll（在Linux上）或kqueue（在BSD系统上），这些新的机制提供了更好的性能和可扩展性。
维护代码可读性：即便select的使用比较直观，仍推荐将复用逻辑封装在清晰定义的函数中，保持代码的可维护性。

6.代码

一个TCP方式监听8888端口的echo服务端，可使用nc命令进行发送消息测试。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8888
#define BUF_SIZE 1024
#define MAX_CLIENTS 30

void error(const char *msg) {
    perror(msg);
    exit(1);
}

int main() {
    int opt = 1;
    int master_socket, addrlen, new_socket, client_socket[MAX_CLIENTS];
    int max_sd, sd, activity, i, valread;
    struct sockaddr_in address;
    char buffer[BUF_SIZE];  // 数据缓冲区
    fd_set readfds;  // 描述符集合

    // 初始化所有 client_socket[] 为 0，表示可用位置
    for (i = 0; i < MAX_CLIENTS; i++) {
        client_socket[i] = 0;
    }

    // 创建主套接字
    if ((master_socket = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        error("socket failed");
    }

    // 设置套接字选项，允许多次绑定同一个地址。对于 TCP，必须在 bind 前设置
    if (setsockopt(master_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        error("setsockopt");
    }

    // 类型为 IPv4 ，端口为 PORT
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;  // 自动选择一个有效的 IP 地址
    address.sin_port = htons(PORT);

    // 绑定套接字到端口
    if (bind(master_socket, (struct sockaddr *)&address, sizeof(address)) < 0) {
        error("bind failed");
    }
    printf("Listener on port %d \n", PORT);

    // 最多同时处理 5 个连接请求
    if (listen(master_socket, 5) < 0) {
        error("listen");
    }

    // 接受即将到来的连接
    addrlen = sizeof(address);
    puts("Waiting for connections ...");

    while(1) {
        // 清空套接字集合
        FD_ZERO(&readfds);

        // 添加主套接字到集合中
        FD_SET(master_socket, &readfds);
        max_sd = master_socket;

        // 添加子套接字到集合
        for (i = 0; i < MAX_CLIENTS; i++) {
            sd = client_socket[i];
            if (sd > 0) {
                FD_SET(sd, &readfds);
            }
            if (sd > max_sd) {
                max_sd = sd;
            }
        }

        // 等待某个套接字活动，没有时间限制
        activity = select(max_sd + 1, &readfds, NULL, NULL, NULL);

        if (activity < 0) {
            error("select error");
        }

        // 如果是主套接字活动，处理新的连接
        if (FD_ISSET(master_socket, &readfds)) {
            if ((new_socket = accept(master_socket, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
                error("accept");
            }

            printf("New connection, socket fd is %d, ip is : %s, port : %d\n", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));

            // 将新套接字添加到数组中
            for (i = 0; i < MAX_CLIENTS; i++) {
                if (client_socket[i] == 0) {
                    client_socket[i] = new_socket;
                    printf("Adding to list of sockets as %d\n", i);
                    break;
                }
            }
        }

        // 否则是其他套接字的活动
        for (i = 0; i < MAX_CLIENTS; i++) {
            sd = client_socket[i];
            if (FD_ISSET(sd, &readfds)) {
                // 检查是否是断开连接，是则关闭套接字
                if ((valread = read(sd, buffer, 1024)) == 0) {
                    getpeername(sd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
                    printf("Host disconnected, ip %s, port %d \n", inet_ntoa(address.sin_addr), ntohs(address.sin_port));
                    close(sd);
                    client_socket[i] = 0;
                } else {
                    // 回显收到的消息
                    buffer[valread] = '\0';
                    send(sd, buffer, strlen(buffer), 0);
                }
            }
        }
    }

    return 0;
}

二、poll

poll解决了 select 中存在的一些限制，比如文件描述符数量的限制，并提供了一种更可扩展的方式来处理大量的并发连接。也可以用来监控多个文件描述符上的事件。

1.poll 的基本原理

poll 函数的主要作用是等待一个或多个文件描述符变为就绪状态，或者直到超时。这使得程序可以在一个线程内同时处理多个I/O通道。

2.函数原型

#include <poll.h>

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

－参数说明

fds: 指向 pollfd 结构数组的指针，这个结构用来指定一组要监视的文件描述符及其关注的事件。
nfds: 指定数组 fds 中元素的数量。
timeout: 等待直到某个文件描述符就绪的毫秒数。如果设置为 -1，则永久等待直到有事件发生。

3.pollfd 结构体

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

每个 pollfd 结构包括以下字段：

fd: 文件描述符。
events: 应用程序感兴趣的事件集合。
revents: 实际发生的事件集合，由内核填充。

4.poll 的优点

无描述符限制：与 select 不同，poll 不受 FD_SETSIZE 的限制，因此可以处理超过1024个并发连接。
简单的接口：poll 提供了一个相对简单的接口，可以直观地指定感兴趣的事件并检查事件发生情况。
更好的可扩展性：因为 poll 可以处理更多的连接，它在面对高负载情况下通常比 select 表现得更好。
支持更长的时间间隔：poll 的 timeout 参数是以毫秒为单位，提供了比 select（以秒和微秒为单位）更精细的控制。
简化的状态管理：在 poll 调用中，返回的结果直接反映在各个 pollfd 结构的 revents 字段中，这简化了状态的管理。

5.poll 的局限性

性能问题：对于非常大量的文件描述符集合，尽管 poll 不受 FD_SETSIZE 的限制，但是其性能仍可能因为需要线性遍历所有描述符而受到影响。
缺乏特定优化：poll 在某些系统上没有针对性的优化，如 epoll 在 Linux 上的优化。
频繁的系统调用：在高负载情况下，poll 可能需要频繁地调用和处理，尤其是在很多文件描述符都非常活跃的情况下。

6.最佳实践

适当选择技术：对于小到中等规模的应用，或者是跨平台的项目，使用 poll 是合适的。对于需要处理大量并发连接的高性能 Linux 服务器，考虑使用 epoll。
合理管理文件描述符：即使 poll 可以处理大量的文件描述符，也应该通过适当的系统设计来管理这些描述符，避免不必要的资源消耗。
使用适当的超时值：根据应用的需求合理设置 poll 的超时参数。对于需要即时响应的系统，可以设置较短的超时时间，或使用非阻塞模式。
资源清理：确保在文件描述符关闭前从监视列表中移除，避免 poll 在无效的描述符上浪费时间。
错误处理：妥善处理 poll 返回的错误，特别是在网络编程中，要注意处理如网络断开、超时等常见问题。

7.代码

一个TCP方式监听8888端口的echo服务端，可使用nc命令进行发送消息测试。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <poll.h>
#include <errno.h>

#define PORT 8888
#define MAX_CLIENTS 30
#define BUF_SIZE 1024

void error(const char *msg) {
    perror(msg);
    exit(1);
}

int main() {
    int opt = 1;
    int master_socket, addrlen, new_socket, activity, i, valread, sd;
    struct sockaddr_in address;
    struct pollfd fdset[MAX_CLIENTS + 1];  // +1 是为了主套接字
    char buffer[BUF_SIZE];  // 数据缓冲区

    // 将所有client_socket[]初始化为0，以便不被检查
    for (i = 0; i < MAX_CLIENTS; i++) {
        fdset[i].fd = 0;
        fdset[i].events = POLLIN;
    }

    // 创建主套接字
    if ((master_socket = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        error("socket failed");
    }

    // 设置主套接字以允许多个连接
    if (setsockopt(master_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        error("setsockopt");
    }

    // 创建套接字类型
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 将套接字绑定到本地主机的8888端口
    if (bind(master_socket, (struct sockaddr *)&address, sizeof(address)) < 0) {
        error("bind failed");
    }
    printf("Listener on port %d \n", PORT);

    // 尝试为主套接字指定最多5个挂起连接
    if (listen(master_socket, 5) < 0) {
        error("listen");
    }

    // 接受传入连接
    addrlen = sizeof(address);
    puts("Waiting for connections ...");

    // 将主套接字添加到集合中
    fdset[0].fd = master_socket;
    fdset[0].events = POLLIN;

    while(1) {
        // 等待其中一个套接字上的活动
        activity = poll(fdset, MAX_CLIENTS + 1, -1);

        if ((activity < 0) && (errno != EINTR)) {
            printf("poll error");
        }

        // 如果主套接字上发生了某些事情，则是传入连接
        if (fdset[0].revents & POLLIN) {
            if ((new_socket = accept(master_socket, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
                error("accept");
            }

            printf("New connection, socket fd is %d, ip is : %s, port : %d\n", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));

            // 将新套接字添加到套接字数组中
            for (i = 1; i <= MAX_CLIENTS; i++) {
                if (fdset[i].fd == 0) {
                    fdset[i].fd = new_socket;
                    fdset[i].events = POLLIN;
                    printf("Adding to list of sockets as %d\n", i);
                    break;
                }
            }
        }

        // 否则，它是一些其他套接字上的IO操作
        for (i = 1; i <= MAX_CLIENTS; i++) {
            sd = fdset[i].fd;
            if ((fdset[i].revents & POLLIN) && sd > 0) {
                // 检查是否为关闭，并读取传入消息
                if ((valread = read(sd, buffer, BUF_SIZE)) == 0) {
                    // 有人断开连接，获取其详细信息并打印
                    getpeername(sd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
                    printf("Host disconnected, ip %s, port %d \n", inet_ntoa(address.sin_addr), ntohs(address.sin_port));

                    // 关闭套接字并在列表中标记为0以重用
                    close(sd);
                    fdset[i].fd = 0;
                } else {
                    // 回显收到的消息
                    buffer[valread] = '\0';
                    send(sd, buffer, strlen(buffer), 0);
                }
            }
        }
    }

    return 0;
}

三、epoll

epoll 是 Linux 下的一种高效的 I/O 事件通知机制，尤其适合处理大量并发连接的场景。与传统的 select 和 poll 不同，epoll 在处理大规模文件描述符上的效率更高，主要是因为它的工作方式减少了频繁的文件描述符扫描，并且使用了更加复杂的数据结构（如红黑树和链表）来跟踪活跃的文件描述符。

1.基本原理和特点

epoll 主要提供两种模式：EPOLL_LT（水平触发）和 EPOLL_ET（边缘触发）。水平触发模式下，只要文件描述符还有数据可读，epoll_wait 就会返回它；而边缘触发模式只在状态发生变化时（例如从无数据到有数据）才通知应用程序，这可以减少应用程序被唤醒的次数，提高效率。

epoll 的核心函数包括：

epoll_create：创建一个 epoll 的实例。
epoll_ctl：向 epoll 实例中添加、修改或删除文件描述符。
epoll_wait：等待事件的发生。

2.接口原型

① epoll_ctl 接口

epoll_ctl 函数用于向 epoll 实例添加、修改或删除文件描述符的事件。

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

-参数说明

epfd: epoll 实例的文件描述符，由 epoll_create 或 epoll_create1 创建。
op: 操作类型，指定是添加（EPOLL_CTL_ADD）、修改（EPOLL_CTL_MOD）还是删除（EPOLL_CTL_DEL）。
fd: 需要操作的目标文件描述符。
event: 指向 epoll_event 结构的指针，该结构指定了对应文件描述符上感兴趣的事件以及其他相关选项。

②epoll_wait 接口

epoll_wait 函数等待在 epoll 文件描述符上注册的事件的发生。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

-参数说明

epfd: epoll 实例的文件描述符。
events: 指向 epoll_event 结构数组的指针，该数组用来从内核得到事件的集合。
maxevents: 告诉内核这个事件数组可以接受多少个事件，这个值最大不能超过创建 epoll_create() 时的 size。
timeout: 等待I/O事件发生的超时值（单位：毫秒）。特殊值有：
- -1：永远等待。
- 0：立即返回，不阻塞。

-返回值

返回发生的事件数目，可能为零（在指定的时间间隔内没有任何事件发生）。
-1 表示发生错误，具体错误原因存储在 errno 中。

3.epoll_event 结构体

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

events: 表示关心的事件类型，可能的值包括：
- EPOLLIN：表示对应的文件描述符可以读取（不会阻塞）。
- EPOLLOUT：表示对应的文件描述符可以写入（不会阻塞）。
- EPOLLPRI：表示对应的文件描述符有紧急的数据可读（如 TCP 的带外数据）。
- EPOLLERR：表示对应的文件描述符发生错误。
- EPOLLHUP：表示对应的文件描述符被挂断。
- EPOLLET：将 epoll 行为设置为边缘触发，这是对 EPOLLIN、EPOLLOUT 和 EPOLLPRI 的一种补充。
- EPOLLONESHOT：监听一次事件后，如果还需要继续监听这个文件描述符，需要再次把它加入到 epoll 队列。
data: 是一个联合体，可以用来存储用户定义的数据，常用来标识事件相关的文件描述符。

4.epoll 的优点

高效的事件处理： epoll 只处理活跃的连接，而不像 select 或 poll 那样处理整个文件描述符集，因此它在面对大量并发连接时更为高效。
更大的可扩展性： epoll 可以支持成千上万的并发连接，而不受 FD_SETSIZE 的限制，这使得它在高性能服务器环境中表现出色。
支持两种触发模式：
- 水平触发（LT）：默认模式，只要数据可读写，事件就会持续被报告。
- 边缘触发（ET）：只报告状态改变（如从不可读变为可读），这种模式可以减少事件的触发次数，提高效率，但编程模型更复杂。
减少复制开销：在 epoll 的使用过程中，内核与用户空间之间不需要频繁复制大量的文件描述符数据，这减少了系统的调用开销。

5.epoll 的局限性

平台依赖性： epoll 是 Linux 特有的，不可在其他操作系统如 Windows 或 macOS 上使用，这限制了其跨平台的应用。
编程复杂性：尤其是在边缘触发模式下，epoll 需要更精细的错误处理和状态管理，增加了编程的复杂度。
对旧系统的支持问题：较旧的 Linux 内核可能不支持 epoll，或其实现存在限制，这需要在部署前进行充分的测试和验证。

6.最佳实践

正确选择触发模式：
- 对于简单的应用或新手，建议使用水平触发模式，因为它的行为更符合直觉，易于管理。
- 对于需要极高性能和有经验的开发者，可以选择边缘触发模式，但必须小心处理所有可能的状态，以防止数据丢失或重复处理。
合理配置非阻塞模式：
在使用 epoll，尤其是在边缘触发模式下时，确保所有的 socket 均设置为非阻塞模式。这样可以避免单个慢连接影响到整个服务器的性能。
维护适当的错误处理：
在 epoll 的事件循环中，应该有适当的错误处理逻辑，例如重新连接、资源回收等，以确保应用的稳定运行。确保不会在 epoll 实例中留下无效的文件描述符，避免资源泄露。
使用 epoll_create1 替代 epoll_create：
使用 epoll_create1(0) 可以在创建 epoll 文件描述符时提供更多的功能（如非阻塞），而 epoll_create 已被认为是过时的。
避免死锁和竞态条件：
在设计使用 epoll 的多线程程序时，应该特别注意同步和锁的问题，避免引入死锁或竞态条件。
大规模并发处理：epoll 特别适用于处理大量并发连接的服务器，例如在Web服务器和数据库服务器中。

7.代码

一个TCP方式监听8888端口的echo服务端，可使用nc命令进行发送消息测试。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <fcntl.h>

#define MAX_EVENTS 1024
#define BUF_SIZE 4096
#define PORT 8888

// 设置 socket 为非阻塞模式
int make_socket_non_blocking(int sockfd) {
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl F_GETFL");
        return -1;
    }
    flags |= O_NONBLOCK;
    if (fcntl(sockfd, F_SETFL, flags) == -1) {
        perror("fcntl F_SETFL");
        return -1;
    }
    return 0;
}

// 创建、设置和绑定监听 socket
int create_and_bind() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("socket");
        return -1;
    }

    int opt = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        close(server_fd);
        return -1;
    }

    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind");
        close(server_fd);
        return -1;
    }

    return server_fd;
}

int main() {
    int server_fd = create_and_bind();
    if (server_fd < 0) {
        exit(EXIT_FAILURE);
    }

    make_socket_non_blocking(server_fd);

    if (listen(server_fd, SOMAXCONN) < 0) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
	printf("Listener on port %d, fd:%d.\n", PORT, server_fd);

    int efd = epoll_create1(0); // 创建epoll实例，一般是4，所以epoll客户端fd从5开始
    if (efd == -1) {
        perror("epoll_create");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
	
	printf("epoll_create1 on fd:%d.\n", efd);

    struct epoll_event event;
    event.data.fd = server_fd;
    event.events = EPOLLIN | EPOLLET;  // 使用边缘触发模式
    if (epoll_ctl(efd, EPOLL_CTL_ADD, server_fd, &event) < 0) {
        perror("epoll_ctl");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    struct epoll_event *events = (struct epoll_event *)calloc(MAX_EVENTS, sizeof(event));

    while (1) {
        int n = epoll_wait(efd, events, MAX_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {
                fprintf(stderr, "epoll error\n");
                close(events[i].data.fd);
                continue;
            } else if (server_fd == events[i].data.fd) {
                // 接受所有传入的连接
                while (1) {
                    struct sockaddr_in client_addr;
                    socklen_t in_len = sizeof(client_addr);
                    int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &in_len);
                    if (client_fd == -1) {
                        if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
                            break;  // 处理完所有传入的连接
                        } else {
                            perror("accept");
                            break;
                        }
                    }
					
					printf("New connection, socket fd is %d, ip is : %s, port : %d\n", client_fd, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

                    make_socket_non_blocking(client_fd);

                    event.data.fd = client_fd;
                    event.events = EPOLLIN | EPOLLET;
                    if (epoll_ctl(efd, EPOLL_CTL_ADD, client_fd, &event) < 0) {
                        perror("epoll_ctl");
                        close(client_fd);
                        continue;
                    }
					printf("Adding to list of sockets as %d\n", client_fd);
                }
            } else {
                // 处理客户端数据
                int done = 0;
                while (1) {
                    char buf[BUF_SIZE];
                    ssize_t count = read(events[i].data.fd, buf, sizeof(buf));
                    if (count == -1) {
                        if (errno != EAGAIN) {
                            perror("read");
                            done = 1;
                        }
                        break;
                    } else if (count == 0) {
                        done = 1;
                        break;
                    }

                    ssize_t write_ret = write(events[i].data.fd, buf, count);
                    if (write_ret == -1) {
                        perror("write");
                        done = 1;
                        break;
                    }
                }

                if (done) {
                    printf("Closed connection on descriptor %d\n", events[i].data.fd);
                    close(events[i].data.fd);
                }
            }
        }
    }

    free(events);
    close(server_fd);
    return EXIT_SUCCESS;
}

四、kqueue　［待后续更新］

五、io_ring　［待后续更新］

六、iocp 　［待后续更新］

七、总结

1.横评

I/O多路复用技术是现代操作系统中处理高并发网络请求的关键技术之一，它允许单个进程同时监视多个文件描述符（I/O通道），以便在任何一个文件描述符准备好进行I/O操作时立即通知应用程序。下面是对select、poll、epoll、kqueue、io_uring、iocp这几种I/O多路复用技术的总结分析：

① select

基本原理：support [BSD,Linux ,macOS,Windows,Unix]，select使用位图来跟踪文件描述符的状态，当某个文件描述符准备好进行I/O操作时，select会返回。
限制：select的最大限制是文件描述符的数量，通常为1024。这意味着它不适合处理大量并发连接。
性能：由于每次调用select都需要重新检查所有文件描述符，它的性能随着文件描述符数量的增加而下降。

② poll

基本原理：support [BSD,Linux ,macOS,Windows,Unix]，poll与select类似，但它使用链表来跟踪文件描述符，因此它没有文件描述符数量的限制。
性能：poll的性能比select略好，因为它不需要重新检查所有文件描述符。

③ epoll

基本原理：support [Linux]，epoll是Linux内核中的一个特性，epoll使用红黑树和双向链表来跟踪文件描述符，它能够高效地处理大量并发连接。
特性：epoll支持水平触发（LT）和边缘触发（ET），这使得它能够更精确地控制何时通知应用程序文件描述符的状态变化。
性能：epoll的性能非常高，它能够处理数万个并发连接，并且在文件描述符数量增加时，性能不会显著下降。

④ kqueue

基本原理：support [BSD]，kqueue是BSD系列操作系统中的I/O多路复用技术，它使用事件队列来跟踪文件描述符的状态。
特性：kqueue支持水平触发和边缘触发，并且它能够处理大量并发连接。
性能：kqueue的性能与epoll相当，它也能够处理数万个并发连接。

⑤ io_uring

基本原理：support [Linux]，io_uring是Linux内核中的一个新特性，它提供了一种高效的异步I/O接口。与传统的 epoll 和 kqueue 不同，io_uring 主要用于实现异步 I/O 操作，能够在用户空间中进行零拷贝的数据传输，从而提高了 I/O 操作的效率和性能。
特性：io_uring支持异步I/O操作，它使用一个环形缓冲区来存储I/O请求，这使得它能够高效地处理大量并发I/O操作。是Linux 中用于替代 epoll 和其他 I/O 多路复用机制的新特性。
性能：io_uring的性能非常高，它能够显著提高应用程序的I/O性能。