理解网络IO模型：从阻塞到异步

• 理解网络IO模型：从阻塞到异步
  • 1. 阻塞 I/O（Blocking I/O）
  • 2. 非阻塞 I/O（Non-blocking I/O）
  • 3. I/O 多路复用（I/O Multiplexing）
  • 4. 信号驱动 I/O（Signal-driven I/O）
  • 5. 异步 I/O（Asynchronous I/O，也称为 AIO）
  • 总结

本文包含AIGC内容

网络 I/O 模型是一个重要的概念，它描述了数据在操作系统内核与应用程序之间的传输过程。本文将详细介绍五种主要的网络 I/O 模型：阻塞 I/O、非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。

1. 阻塞 I/O（Blocking I/O）

阻塞 I/O 是最简单的网络 I/O 模型。在这种模型中，应用程序在发起 I/O 操作时会被阻塞，直到操作完成。在此期间，应用程序无法执行其他任务。这种模型的缺点是效率较低，因为应用程序需要等待 I/O 操作完成。

以下是一个使用 C 语言编写的阻塞 I/O 示例，该示例创建了一个简单的 TCP 服务器，接受客户端连接并接收数据：

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

#define BUF_SIZE 1024

int main(int argc, char *argv[]) {
    int serv_sock, clnt_sock;
    char buffer[BUF_SIZE];
    int str_len;

    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;

    if (argc != 2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 配置服务器地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    // 绑定服务器套接字
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 循环接受客户端连接
    while (1) {
        clnt_addr_size = sizeof(clnt_addr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        if (clnt_sock == -1) {
            perror("accept() error");
            break;
        }

        // 接收客户端数据
        while ((str_len = read(clnt_sock, buffer, BUF_SIZE)) != 0) {
            write(clnt_sock, buffer, str_len); // 将接收到的数据回发给客户端
        }

        // 关闭客户端套接字
        close(clnt_sock);
    }

    // 关闭服务器套接字
    close(serv_sock);

    return 0;
}

在这个示例中，服务器使用 accept() 函数等待客户端连接。当客户端连接到服务器时，accept() 函数返回一个新的套接字，用于与客户端通信。由于 accept() 函数是阻塞的，服务器在等待客户端连接时无法执行其他任务。

同样，服务器使用阻塞的 read() 函数接收客户端发送的数据。当客户端发送数据时，read() 函数返回接收到的数据长度。如果没有数据可读，read() 函数将阻塞，直到有数据可读或连接关闭。

这个简单的阻塞 I/O 示例展示了阻塞 I/O 模型的基本原理。在实际应用中，阻塞 I/O 可能导致服务器性能较低，特别是在处理大量并发连接时。为了提高性能，可以考虑使用其他 I/O 模型，如非阻塞 I/O、I/O 多路复用等。

2. 非阻塞 I/O（Non-blocking I/O）

非阻塞 I/O 模型允许应用程序在发起 I/O 操作时不被阻塞。如果操作不能立即完成，系统会返回一个错误码，表示当前无法执行该操作。应用程序需要不断轮询 I/O 操作的状态，以确定何时可以继续执行。这种模型的优点是应用程序可以在等待 I/O 操作时执行其他任务，但缺点是需要不断轮询，可能导致 CPU 资源浪费。

以下是一个使用 C 语言编写的非阻塞 I/O 示例，该示例创建了一个简单的 TCP 服务器，接受客户端连接并接收数据：

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

#define BUF_SIZE 1024

int main(int argc, char *argv[]) {
    int serv_sock, clnt_sock;
    char buffer[BUF_SIZE];
    int str_len;

    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;

    if (argc != 2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 配置服务器地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    // 绑定服务器套接字
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 设置服务器套接字为非阻塞模式
    int flags = fcntl(serv_sock, F_GETFL, 0);
    fcntl(serv_sock, F_SETFL, flags | O_NONBLOCK);

    // 循环接受客户端连接
    while (1) {
        clnt_addr_size = sizeof(clnt_addr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        if (clnt_sock == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 没有新的客户端连接，可以在此执行其他任务
                usleep(100000); // 休眠 100 毫秒
                continue;
            } else {
                perror("accept() error");
                break;
            }
        }

        // 设置客户端套接字为非阻塞模式
        flags = fcntl(clnt_sock, F_GETFL, 0);
        fcntl(clnt_sock, F_SETFL, flags | O_NONBLOCK);

        // 接收客户端数据
        while (1) {
            str_len = read(clnt_sock, buffer, BUF_SIZE);
            if (str_len == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    // 没有数据可读，可以在此执行其他任务
                    usleep(100000); // 休眠 100 毫秒
                    continue;
                } else {
                    perror("read() error");
                    break;
                }
            } else if (str_len == 0) {
                // 客户端关闭连接
                break;
            } else {
                write(clnt_sock, buffer, str_len); // 将接收到的数据回发给客户端
            }
        }

        // 关闭客户端套接字
        close(clnt_sock);
    }

    // 关闭服务器套接字
    close(serv_sock);

    return 0;
}

在这个示例中，服务器使用 fcntl() 函数将服务器套接字和客户端套接字设置为非阻塞模式。当 accept() 函数没有新的客户端连接时，它会立即返回 -1，并设置 errno 为 EAGAIN 或 EWOULDBLOCK。服务器可以在此时执行其他任务，如处理已连接的客户端请求。

同样，当 read() 函数没有数据可读时，它会立即返回 -1，并设置 errno 为 EAGAIN 或 EWOULDBLOCK。服务器可以在此时执行其他任务，如处理其他客户端的请求。

这个简单的非阻塞 I/O 示例展示了非阻塞 I/O 模型的基本原理。在实际应用中，非阻塞 I/O 可以提高服务器的并发性能，但需要不断轮询 I/O 操作的状态，可能导致 CPU 资源浪费。为了解决这个问题，可以考虑使用 I/O 多路复用模型。

3. I/O 多路复用（I/O Multiplexing）

I/O 多路复用模型允许应用程序同时监视多个 I/O 事件，当某个事件发生时，应用程序可以立即处理。这种模型使用了 select、poll 或 epoll 等系统调用来实现。I/O 多路复用模型的优点是可以在单个线程中处理多个 I/O 事件，提高了程序的并发性能。但是，它仍然需要在用户空间和内核空间之间进行数据拷贝。

以下是一个使用 select 实现的 I/O 多路复用的简单服务器示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>

#define BUF_SIZE 100
#define MAX_CLIENTS 10

int main(int argc, char *argv[]) {
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;
    char buffer[BUF_SIZE];
    int str_len;

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 初始化服务器地址结构
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    // 绑定服务器套接字
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 初始化 select 相关变量
    fd_set read_fds, tmp_fds;
    int fd_max = serv_sock;
    int client_socks[MAX_CLIENTS];
    int client_count = 0;
    int i;

    for (i = 0; i < MAX_CLIENTS; i++) {
        client_socks[i] = -1;
    }

    FD_ZERO(&read_fds);
    FD_SET(serv_sock, &read_fds);

    // 循环处理 I/O 事件
    while (1) {
        tmp_fds = read_fds;
        struct timeval timeout;
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;

        int event_count = select(fd_max + 1, &tmp_fds, NULL, NULL, &timeout);
        if (event_count == -1) {
            perror("select() error");
            break;
        } else if (event_count == 0) {
            printf("No I/O event occurred. Waiting...\n");
            continue;
        }

        for (i = 0; i <= fd_max; i++) {
            if (FD_ISSET(i, &tmp_fds)) {
                if (i == serv_sock) { // 有新的客户端连接
                    clnt_addr_size = sizeof(clnt_addr);
                    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
                    if (client_count < MAX_CLIENTS) {
                        client_socks[client_count++] = clnt_sock;
                        FD_SET(clnt_sock, &read_fds);
                        if (clnt_sock > fd_max) {
                            fd_max = clnt_sock;
                        }
                        printf("New client connected: %d\n", clnt_sock);
                    } else {
                        printf("Client limit exceeded. Connection rejected.\n");
                        close(clnt_sock);
                    }
                } else { // 有客户端发送数据
                    str_len = read(i, buffer, BUF_SIZE);
                    if (str_len == 0) { // 客户端关闭连接
                        FD_CLR(i, &read_fds);
                        close(i);
                        for (int j = 0; j < client_count; j++) {
                            if (client_socks[j] == i) {
                                client_socks[j] = -1;
                                break;
                            }
                        }
                        printf("Client disconnected: %d\n", i);
                    } else { // 接收到客户端数据
                        write(i, buffer, str_len); // 将接收到的数据回发给客户端
                    }
                }
            }
        }
    }

    // 关闭服务器套接字
    close(serv_sock);

    return 0;
}

在这个示例中，服务器使用 select 系统调用来同时监视服务器套接字和所有客户端套接字的 I/O 事件。当有新的客户端连接时，服务器会接受连接并将客户端套接字添加到监视集合中。当有客户端发送数据时，服务器会接收数据并将数据回发给客户端。

这个简单的 I/O 多路复用示例展示了 I/O 多路复用模型的基本原理。在实际应用中，I/O 多路复用可以提高服务器的并发性能，但仍然需要在用户空间和内核空间之间进行数据拷贝。为了解决这个问题，可以考虑使用更高效的 I/O 多路复用技术，如 epoll。

以下是一个使用 epoll 的 C 语言示例，该示例创建了一个简单的 TCP 服务器，接受客户端连接并接收数据：

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

#define BUF_SIZE 1024
#define MAX_EVENTS 100

int main(int argc, char *argv[]) {
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;
    char buffer[BUF_SIZE];
    int str_len;

    if (argc != 2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 配置服务器地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    // 绑定服务器套接字
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 创建 epoll 实例
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1() error");
        exit(1);
    }

    // 将服务器套接字添加到 epoll 实例
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = serv_sock;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, serv_sock, &ev) == -1) {
        perror("epoll_ctl() error");
        exit(1);
    }

    // 初始化事件数组
    struct epoll_event events[MAX_EVENTS];

    // 循环处理 I/O 事件
    while (1) {
        int event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (event_count == -1) {
            perror("epoll_wait() error");
            break;
        }

        for (int i = 0; i < event_count; i++) {
            if (events[i].data.fd == serv_sock) { // 有新的客户端连接
                clnt_addr_size = sizeof(clnt_addr);
                clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
                if (clnt_sock == -1) {
                    perror("accept() error");
                    continue;
                }

                // 将客户端套接字添加到 epoll 实例
                ev.events = EPOLLIN;
                ev.data.fd = clnt_sock;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, clnt_sock, &ev) == -1) {
                    perror("epoll_ctl() error");
                    exit(1);
                }

                printf("New client connected: %d\n", clnt_sock);
            } else { // 有客户端发送数据
                str_len = read(events[i].data.fd, buffer, BUF_SIZE);
                if (str_len == 0) { // 客户端关闭连接
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                    close(events[i].data.fd);
                    printf("Client disconnected: %d\n", events[i].data.fd);
                } else { // 接收到客户端数据
                    write(events[i].data.fd, buffer, str_len); // 将接收到的数据回发给客户端
                }
            }
        }
    }

    // 关闭服务器套接字和 epoll 实例
    close(serv_sock);
    close(epoll_fd);

    return 0;
}

在这个示例中，服务器使用 epoll 系统调用来同时监视服务器套接字和所有客户端套接字的 I/O 事件。当有新的客户端连接时，服务器会接受连接并将客户端套接字添加到 epoll 实例。当有客户端发送数据时，服务器会接收数据并将数据回发给客户端。

这个简单的 I/O 多路复用示例展示了 epoll 的基本原理。epoll 在处理大量并发连接时具有更高的性能和可扩展性，因此在高并发场景下表现更优。

4. 信号驱动 I/O（Signal-driven I/O）

信号驱动 I/O 模型使用信号来通知应用程序 I/O 事件的发生。当 I/O 事件发生时，操作系统会发送一个信号给应用程序，应用程序可以在信号处理函数中处理事件。这种模型的优点是应用程序不需要轮询 I/O 操作的状态，但缺点是信号处理机制相对复杂，且仍然需要在用户空间和内核空间之间进行数据拷贝。

以下是一个使用信号驱动 I/O 的 C 语言示例，该示例创建了一个简单的 TCP 服务器，接受客户端连接并接收数据：

#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 <signal.h>
#include <fcntl.h>
#include <errno.h>

#define BUF_SIZE 1024
#define MAX_CLNT 1024

void sig_handler(int signo);
int clnt_cnt = 0;
int clnt_socks[MAX_CLNT];
int serv_sock;

int main(int argc, char *argv[]) {
    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;
    int clnt_sock;
    struct sigaction act;
    int str_len;
    char buf[BUF_SIZE];

    if (argc != 2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    // 设置信号处理函数
    act.sa_handler = sig_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGIO, &act, 0);

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 设置套接字选项，允许重用本地地址和端口
    int optval = 1;
    setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

    // 绑定服务器套接字
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 设置服务器套接字为非阻塞模式
    int flag = fcntl(serv_sock, F_GETFL, 0);
    fcntl(serv_sock, F_SETFL, flag | O_NONBLOCK);

    // 设置服务器套接字的信号驱动 I/O
    fcntl(serv_sock, F_SETOWN, getpid());
    fcntl(serv_sock, F_SETSIG, SIGIO);
    fcntl(serv_sock, F_SETFL, O_ASYNC);

    // 循环处理 I/O 事件
    while (1) {
        sleep(1);
    }

    // 关闭服务器套接字
    close(serv_sock);

    return 0;
}

void sig_handler(int signo) {
    if (signo == SIGIO) {
        int clnt_sock;
        struct sockaddr_in clnt_addr;
        socklen_t clnt_addr_size = sizeof(clnt_addr);

        // 接受客户端连接
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        if (clnt_sock == -1) {
            perror("accept() error");
            return;
        }

        // 将客户端套接字添加到客户端套接字数组
        clnt_socks[clnt_cnt++] = clnt_sock;

        // 设置客户端套接字的信号驱动 I/O
        fcntl(clnt_sock, F_SETOWN, getpid());
        fcntl(clnt_sock, F_SETSIG, SIGIO);
        fcntl(clnt_sock, F_SETFL, O_ASYNC);

        printf("New client connected: %d\n", clnt_sock);
    } else {
        for (int i = 0; i < clnt_cnt; i++) {
            int str_len;
            char buf[BUF_SIZE];

            // 接收客户端数据
            str_len = read(clnt_socks[i], buf, BUF_SIZE);
            if (str_len == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    continue;
                } else {
                    perror("read() error");
                    exit(1);
                }
            } else if (str_len == 0) {
                // 客户端关闭连接
                printf("Client disconnected: %d\n", clnt_socks[i]);
                close(clnt_socks[i]);
                clnt_socks[i] = -1;
            } else {
                // 将接收到的数据回发给客户端
                write(clnt_socks[i], buf, str_len);
            }
        }
    }
}

在这个示例中，服务器使用信号驱动 I/O 来处理客户端连接和数据接收。当有新的客户端连接或客户端发送数据时，操作系统会发送一个 SIGIO 信号给应用程序。应用程序在信号处理函数 sig_handler() 中处理这些事件。

这个简单的信号驱动 I/O 示例展示了信号驱动 I/O 模型的基本原理。虽然信号驱动 I/O 可以避免轮询 I/O 操作的状态，但信号处理机制相对复杂，且仍然需要在用户空间和内核空间之间进行数据拷贝。为了解决这个问题，可以考虑使用异步 I/O 模型。

5. 异步 I/O（Asynchronous I/O，也称为 AIO）

异步 I/O 模型允许应用程序发起 I/O 操作后立即返回，而不需要等待操作完成。当 I/O 操作完成时，操作系统会通知应用程序。这种模型的优点是应用程序可以在等待 I/O 操作时执行其他任务，且无需轮询。异步 I/O 模型在用户空间和内核空间之间的数据拷贝次数也较少，从而提高了效率。

以下是一个使用异步 I/O 的 C 语言示例：

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

#define BUF_SIZE 1024
#define MAX_CLIENTS 10

int serv_sock;
int clnt_socks[MAX_CLIENTS];
int clnt_cnt = 0;

void sig_handler(int signo);

int main() {
    struct sockaddr_in serv_addr, clnt_addr;
    socklen_t clnt_addr_size;

    // 创建服务器套接字
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1) {
        perror("socket() error");
        exit(1);
    }

    // 绑定服务器套接字
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(12345);

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind() error");
        exit(1);
    }

    // 监听服务器套接字
    if (listen(serv_sock, 5) == -1) {
        perror("listen() error");
        exit(1);
    }

    // 初始化客户端套接字数组
    for (int i = 0; i < MAX_CLIENTS; i++) {
        clnt_socks[i] = -1;
    }

    // 设置信号处理函数
    signal(SIGIO, sig_handler);

    // 设置服务器套接字的异步 I/O
    fcntl(serv_sock, F_SETOWN, getpid());
    fcntl(serv_sock, F_SETSIG, SIGIO);
    fcntl(serv_sock, F_SETFL, O_ASYNC);

    // 循环处理 I/O 事件
    while (1) {
        sleep(1);
    }

    // 关闭服务器套接字
    close(serv_sock);

    return 0;
}

void sig_handler(int signo) {
    if (signo == SIGIO) {
        int clnt_sock;
        struct sockaddr_in clnt_addr;
        socklen_t clnt_addr_size = sizeof(clnt_addr);

        // 接受客户端连接
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        if (clnt_sock == -1) {
            perror("accept() error");
            return;
        }

        // 将客户端套接字添加到客户端套接字数组
        clnt_socks[clnt_cnt++] = clnt_sock;

        // 设置客户端套接字的异步 I/O
        fcntl(clnt_sock, F_SETOWN, getpid());
        fcntl(clnt_sock, F_SETSIG, SIGIO);
        fcntl(clnt_sock, F_SETFL, O_ASYNC);

        printf("New client connected: %d\n", clnt_sock);
    } else {
        for (int i = 0; i < clnt_cnt; i++) {
            int str_len;
            char buf[BUF_SIZE];

            // 接收客户端数据
            str_len = read(clnt_socks[i], buf, BUF_SIZE);
            if (str_len == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    continue;
                } else {
                    perror("read() error");
                    exit(1);
                }
            } else if (str_len == 0) {
                // 客户端关闭连接
                printf("Client disconnected: %d\n", clnt_socks[i]);
                close(clnt_socks[i]);
                clnt_socks[i] = -1;
            } else {
                // 将接收到的数据回发给客户端
                write(clnt_socks[i], buf, str_len);
            }
        }
    }
}

在这个示例中，服务器使用异步 I/O 来处理客户端连接和数据接收。当有新的客户端连接或客户端发送数据时，操作系统会发送一个 SIGIO 信号给应用程序。应用程序在信号处理函数 sig_handler() 中处理这些事件。

这个简单的异步 I/O 示例展示了异步 I/O 模型的基本原理。异步 I/O 可以避免轮询 I/O 操作的状态，提高服务器的并发性能，且在用户空间和内核空间之间的数据拷贝次数较少。

总结

这五种网络 I/O 模型各有优缺点，适用于不同的场景和需求。在实际应用中，可以根据具体情况选择合适的 I/O 模型来提高程序的性能和响应速度。

1. 阻塞 I/O：适用于简单的网络应用，但在高并发场景下性能较低。
2. 非阻塞 I/O：提高了并发性能，但需要不断轮询，可能导致 CPU 资源浪费。
3. I/O 多路复用：在单个线程中处理多个 I/O 事件，提高了并发性能，适用于高并发场景。
4. 信号驱动 I/O：避免轮询，但信号处理机制相对复杂。
5. 异步 I/O：提高并发性能，避免轮询，且在用户空间和内核空间之间的数据拷贝次数较少，适用于高性能服务器。