详解网络IO模型第二章：深入讲解IO模型

一、IO模型的核心概念：阻塞与非阻塞、同步与异步

IO模型的核心是操作系统如何处理数据的读写操作，其分类主要基于两个维度：阻塞/非阻塞和同步/异步。

1. 阻塞与非阻塞

• 阻塞IO：当进程发起IO请求时，若数据未就绪，内核会挂起进程，直到数据准备好。例如，read()函数在数据未到达时会一直等待。
• 非阻塞IO：进程发起IO请求后，若数据未就绪，内核立即返回错误（如EAGAIN或EWOULDBLOCK），进程可通过轮询或事件通知机制继续尝试。例如，通过fcntl()设置文件描述符为非阻塞模式后，read()会立即返回。

2. 同步与异步

• 同步IO：进程需主动等待IO操作完成（如阻塞IO），或通过轮询/事件通知检查状态（如非阻塞IO、IO多路复用）。数据从内核缓冲区复制到用户缓冲区的过程由进程完成。
• 异步IO：进程发起请求后，内核负责完成数据读取和缓冲区复制，完成后通过回调或信号通知进程。例如，Linux的aio_read()函数。

关键区别：同步IO的“同步”指数据复制阶段的同步，而异步IO的“异步”指整个操作（包括数据准备和复制）均由内核完成。

二、五种主流IO模型的深度解析

1. 阻塞IO（Blocking IO）

原理：进程发起IO请求后，若数据未就绪，内核将进程挂起，直到数据到达并完成复制。
适用场景：简单、低并发的应用（如单机工具）。
代码示例（C语言）：

int fd = open("file.txt", O_RDONLY);
char buf[1024];
ssize_t n = read(fd, buf, sizeof(buf)); // 阻塞直到数据就绪
if (n > 0) {
    printf("Read %zd bytes\n", n);
}

缺点：高并发时线程/进程资源消耗大（每个连接需一个线程）。

2. 非阻塞IO（Non-blocking IO）

原理：进程发起IO请求后，若数据未就绪，内核立即返回错误，进程通过轮询或事件通知继续尝试。
适用场景：需要快速响应但允许短暂延迟的场景（如游戏服务器）。
代码示例（设置非阻塞模式）：

int fd = open("file.txt", O_RDONLY | O_NONBLOCK); // 设置为非阻塞
char buf[1024];
while (1) {
    ssize_t n = read(fd, buf, sizeof(buf));
    if (n > 0) {
        break; // 数据就绪
    } else if (errno == EAGAIN) {
        usleep(1000); // 短暂等待后重试
    } else {
        perror("read");
        break;
    }
}

缺点：频繁轮询浪费CPU资源。

3. IO多路复用（IO Multiplexing）

原理：通过单个线程监控多个文件描述符的状态变化（如可读、可写、异常），仅当事件就绪时才进行实际IO操作。
核心机制：

• select：跨平台但效率低（需重新初始化描述符集）。
• poll：改进select，使用链表存储描述符，无数量限制。
• epoll（Linux特有）：基于事件回调，高效处理大量连接。

适用场景：高并发服务器（如Web服务器、聊天应用）。
代码示例（epoll）：

int epoll_fd = epoll_create1(0);
struct epoll_event event, events[10];
event.events = EPOLLIN;
event.data.fd = sockfd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &event);
while (1) {
    int n = epoll_wait(epoll_fd, events, 10, -1);
    for (int i = 0; i < n; i++) {
        if (events[i].events & EPOLLIN) {
            char buf[1024];
            read(events[i].data.fd, buf, sizeof(buf));
        }
    }
}

优点：单线程可处理数万连接，资源占用低。

4. 信号驱动IO（Signal-Driven IO）

原理：进程通过sigaction()注册信号处理函数，当数据就绪时，内核发送SIGIO信号，进程在信号处理函数中执行IO操作。
适用场景：需要异步通知但无需复杂事件循环的场景。
代码示例：

void sigio_handler(int sig) {
    char buf[1024];
    read(sockfd, buf, sizeof(buf));
}
int main() {
    signal(SIGIO, sigio_handler);
    fcntl(sockfd, F_SETOWN, getpid());
    int flags = fcntl(sockfd, F_GETFL);
    fcntl(sockfd, F_SETFL, flags | O_ASYNC); // 启用信号驱动IO
    // ...
}

缺点：信号处理函数中不宜执行复杂逻辑，且信号可能丢失。

5. 异步IO（Asynchronous IO）

原理：进程发起请求后，内核完成数据读取和缓冲区复制，通过回调或信号通知进程。
适用场景：对延迟敏感的高性能应用（如金融交易系统）。
代码示例（Linux AIO）：

#include <libaio.h>
void aio_completion_handler(sigval_t sigval) {
    struct iocb *cb = (struct iocb *)sigval.sival_ptr;
    struct io_event event;
    io_getevents(cb->aio_context, 1, &event, NULL);
    printf("Async read completed\n");
}
int main() {
    struct iocb cb;
    struct iocb *cbs[] = {&cb};
    char buf[1024];
    io_prep_pread(&cb, fd, buf, sizeof(buf), 0);
    cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
    cb.aio_sigevent.sigev_notify_function = aio_completion_handler;
    cb.aio_sigevent.sigev_value.sival_ptr = &cb;
    io_setup(1, &cb.aio_context);
    io_submit(cb.aio_context, 1, cbs);
    // ...
}

优点：真正实现异步，进程无需等待。
缺点：实现复杂，部分平台支持有限。

三、IO模型的选择建议

1. 低并发场景：阻塞IO或非阻塞IO（简单易用）。
2. 高并发场景：IO多路复用（epoll/kqueue）。
3. 超低延迟需求：异步IO（需平台支持）。
4. 避免信号驱动IO：信号处理复杂，易引发竞态条件。

四、总结

理解IO模型的核心在于区分数据准备阶段和数据复制阶段的阻塞/同步行为。阻塞IO适合简单场景，非阻塞IO需配合轮询，IO多路复用是高性能服务器的首选，而异步IO则代表未来方向。开发者应根据业务需求、平台支持和开发复杂度综合选择。