一、同步阻塞IO（Blocking IO）

同步阻塞IO是Linux系统中最基础的IO模型，其核心特征在于用户线程在发起IO请求后会被完全阻塞，直到内核完成数据准备并复制到用户缓冲区。这种模型下，线程在等待阶段无法执行其他任务，资源利用率较低。

底层机制：
当调用read()系统调用时，内核首先检查数据是否就绪。若未就绪，线程会进入休眠状态，直到数据到达并完成从内核缓冲区到用户缓冲区的复制。整个过程通过系统调用陷入内核态完成，用户线程无感知。

代码示例：

#include <unistd.h>
#include <stdio.h>
int main() {
    char buffer[1024];
    ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        write(STDOUT_FILENO, buffer, bytes_read);
    }
    return 0;
}

典型场景：
适用于简单命令行工具或单线程场景，如cat命令读取文件。其优势在于实现简单，但并发能力差，高并发场景下需为每个连接创建独立线程，导致线程切换开销剧增。

二、同步非阻塞IO（Non-blocking IO）

同步非阻塞IO通过文件描述符的O_NONBLOCK标志实现，用户线程发起IO请求后立即返回，若数据未就绪则返回EAGAIN或EWOULDBLOCK错误。线程需通过轮询检查数据状态，避免了完全阻塞。

底层机制：
内核在收到非阻塞IO请求时，若数据未就绪，立即返回错误而非阻塞线程。用户线程需自行实现循环检查，直到数据就绪后完成读取。

代码示例：

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
int main() {
    int fd = STDIN_FILENO;
    set_nonblocking(fd);
    char buffer[1024];
    while (1) {
        ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
        if (bytes_read > 0) {
            write(STDOUT_FILENO, buffer, bytes_read);
            break;
        } else if (bytes_read == -1 && errno != EAGAIN) {
            perror("read error");
            break;
        }
        // 短暂休眠避免CPU空转
        usleep(1000);
    }
    return 0;
}

典型场景：
适用于需要同时处理多个低频IO的场景，如监控系统日志。但轮询机制导致CPU资源浪费，高并发时性能下降明显。

三、IO多路复用（IO Multiplexing）

IO多路复用通过单个线程监控多个文件描述符的状态变化，解决了同步非阻塞的轮询效率问题。Linux提供select、poll、epoll三种实现，其中epoll性能最优。

底层机制：

• select/poll：通过用户态到内核态的数据拷贝传递文件描述符集合，内核遍历检查就绪状态，时间复杂度O(n)。
• epoll：使用红黑树管理文件描述符，通过回调机制通知就绪事件，时间复杂度O(1)。支持ET（边缘触发）和LT（水平触发）两种模式。

代码示例（epoll）：

#include <sys/epoll.h>
#include <unistd.h>
int main() {
    int epoll_fd = epoll_create1(0);
    struct epoll_event event, events[10];
    event.events = EPOLLIN;
    event.data.fd = STDIN_FILENO;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, STDIN_FILENO, &event);
    while (1) {
        int nfds = epoll_wait(epoll_fd, events, 10, -1);
        for (int i = 0; i < nfds; i++) {
            if (events[i].data.fd == STDIN_FILENO) {
                char buffer[1024];
                ssize_t bytes_read = read(events[i].data.fd, buffer, sizeof(buffer));
                if (bytes_read > 0) {
                    write(STDOUT_FILENO, buffer, bytes_read);
                }
            }
        }
    }
    return 0;
}

典型场景：
Nginx、Redis等高并发服务器采用epoll实现单线程处理数万连接。其优势在于减少线程数量，但需处理epoll_wait返回后的业务逻辑分发。

四、信号驱动IO（Signal-Driven IO）

信号驱动IO通过注册SIGIO信号，在数据就绪时内核发送信号通知用户线程，避免轮询开销。用户线程在信号处理函数中完成数据读取。

底层机制：

1. 设置文件描述符为异步通知模式（fcntl(fd, F_SETOWN, getpid())）。
2. 注册SIGIO信号处理函数。
3. 内核在数据就绪时发送SIGIO信号，触发处理函数。

代码示例：

#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
void sigio_handler(int sig) {
    char buffer[1024];
    ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        write(STDOUT_FILENO, buffer, bytes_read);
    }
}
int main() {
    signal(SIGIO, sigio_handler);
    int fd = STDIN_FILENO;
    fcntl(fd, F_SETOWN, getpid());
    int flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_ASYNC);
    while (1) {
        pause(); // 等待信号
    }
    return 0;
}

典型场景：
适用于需要低延迟响应的场景，如交互式终端。但信号处理函数需为异步安全，且信号丢失可能导致数据滞留。

五、异步IO（Asynchronous IO）

异步IO由POSIX标准定义，通过aio_read等函数实现。用户线程发起请求后立即返回，内核在数据复制到用户缓冲区后通过回调或信号通知完成。

底层机制：
Linux通过libaio库实现，内核维护独立线程池处理IO请求。用户线程通过io_setup创建异步上下文，io_submit提交请求，io_getevents获取完成事件。

代码示例：

#include <libaio.h>
#include <unistd.h>
int main() {
    io_context_t ctx;
    io_setup(1, &ctx);
    struct iocb cb = {0};
    struct iocb *cbs[] = {&cb};
    char buffer[1024];
    io_prep_pread(&cb, STDIN_FILENO, buffer, sizeof(buffer), 0);
    cb.data = buffer;
    io_submit(ctx, 1, cbs);
    struct io_event events[1];
    io_getevents(ctx, 1, 1, events, NULL);
    write(STDOUT_FILENO, buffer, events[0].res);
    io_destroy(ctx);
    return 0;
}

典型场景：
数据库系统（如Oracle）利用异步IO实现非阻塞磁盘访问。其优势在于完全解耦IO与计算，但实现复杂，需处理回调上下文管理。

六、模型对比与选型建议

模型	阻塞性	并发能力	实现复杂度	适用场景
同步阻塞IO	高	低	低	简单工具
同步非阻塞IO	中	中	中	低频多路IO
IO多路复用	低	高	中高	高并发服务器
信号驱动IO	低	中	高	交互式应用
异步IO	无	高	高	数据库、存储系统

选型原则：

1. 低并发简单场景：优先选择同步阻塞IO，降低开发复杂度。
2. 中高并发场景：采用epoll（Linux）或kqueue（BSD）实现IO多路复用。
3. 超高性能需求：评估异步IO的收益与实现成本，数据库类系统可考虑。
4. 实时性要求：信号驱动IO适合低延迟场景，但需处理信号安全性问题。

七、总结

Linux的五种IO模型覆盖了从简单到复杂的全部需求场景。开发者需根据业务特性（并发量、延迟敏感度、开发成本）选择合适模型。现代高并发系统通常结合epoll与线程池，在保证性能的同时简化异步编程复杂度。理解底层机制有助于在架构设计中做出最优决策，避免盲目追求新技术导致的过度设计。