知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 04 - I/O 模型详解 ## 五种 I/O 模型 Unix/Linux 下有五种 I/O 模型(来自《UNIX 网络编程》): ``` 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) ``` ### 两个阶段 每次 I/O 操作都包含两个阶段: ``` 阶段 1:等待数据就绪(数据从设备/网络到达内核缓冲区) 阶段 2:数据拷贝(数据从内核缓冲区拷贝到用户缓冲区) 同步 vs 异步的区别在于:阶段 2 是否阻塞用户进程 阻塞 vs 非阻塞的区别在于:阶段 1 是否阻塞用户进程 ``` ## 1. 阻塞 I/O(Blocking I/O)  *图:阻塞 I/O:等待数据与拷贝数据两阶段都挂起* ``` 用户进程 内核 │ │ │── recvfrom() ─────────→│ │ │ 等待数据... │ 阻塞(进程挂起) │ 等待数据... │ │ 数据到达 │ │ 拷贝数据到用户空间 │←── 返回数据 ───────────│ │ │ ``` ```c // 默认情况下,socket 是阻塞的 int fd = socket(AF_INET, SOCK_STREAM, 0); char buf[1024]; ssize_t n = recv(fd, buf, sizeof(buf), 0); // 阻塞,直到有数据 ``` 特点: - 最简单的模型 - 进程在两个阶段都被阻塞 - 一个线程只能处理一个连接 ## 2. 非阻塞 I/O(Non-blocking I/O)  *图:非阻塞 I/O 轮询:反复 recvfrom 直到就绪* ``` 用户进程 内核 │ │ │── recvfrom() ─────────→│ 数据未就绪 │←── EAGAIN ─────────────│ │ │ │── recvfrom() ─────────→│ 数据未就绪 │←── EAGAIN ─────────────│ │ │ │── recvfrom() ─────────→│ 数据就绪 │ │ 拷贝数据到用户空间(阻塞) │←── 返回数据 ───────────│ │ │ ``` ```c // 设置非阻塞 int flags = fcntl(fd, F_GETFL, 0); fcntl(fd, F_SETFL, flags | O_NONBLOCK); // 或创建时指定 int fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0); // 非阻塞读取 while (true) { ssize_t n = recv(fd, buf, sizeof(buf), 0); if (n > 0) { // 处理数据 break; } else if (n == -1 && errno == EAGAIN) { // 数据未就绪,继续轮询(忙等待) continue; } else { // 错误或连接关闭 break; } } ``` 特点: - 阶段 1 不阻塞,但需要轮询(忙等待,浪费 CPU) - 阶段 2 仍然阻塞 - 单独使用意义不大,通常配合 I/O 多路复用 ## 3. I/O 多路复用(I/O Multiplexing) 一个线程同时监控多个 fd,哪个就绪就处理哪个。  *图:select 阻塞等待多个 fd,fd3 就绪后再取数据* ``` 用户进程 内核 │ │ │── select(fds) ────────→│ 监控多个 fd │ │ 等待任一 fd 就绪... │ 阻塞在 select │ fd3 数据到达 │←── fd3 就绪 ───────────│ │ │ │── recvfrom(fd3) ──────→│ │ │ 拷贝数据 │←── 返回数据 ───────────│ │ │ ``` ### select ```c fd_set readfds; FD_ZERO(&readfds); FD_SET(fd1, &readfds); FD_SET(fd2, &readfds); FD_SET(fd3, &readfds); struct timeval timeout = {5, 0}; // 5 秒超时 int ready = select(maxfd + 1, &readfds, NULL, NULL, &timeout); if (ready > 0) { if (FD_ISSET(fd1, &readfds)) { /* fd1 可读 */ } if (FD_ISSET(fd2, &readfds)) { /* fd2 可读 */ } if (FD_ISSET(fd3, &readfds)) { /* fd3 可读 */ } } ``` select 的缺点: - fd 数量限制(默认 1024,FD_SETSIZE) - 每次调用都要把 fd_set 从用户态拷贝到内核态 - 返回后需要遍历所有 fd 才能找到就绪的 - 时间复杂度 O(n) ### poll ```c struct pollfd fds[3]; fds[0] = {.fd = fd1, .events = POLLIN}; fds[1] = {.fd = fd2, .events = POLLIN}; fds[2] = {.fd = fd3, .events = POLLIN}; int ready = poll(fds, 3, 5000); // 5 秒超时 if (ready > 0) { for (int i = 0; i < 3; i++) { if (fds[i].revents & POLLIN) { // fds[i].fd 可读 } } } ``` poll vs select: - 没有 fd 数量限制(使用链表) - 仍然需要遍历所有 fd - 仍然需要每次拷贝 fd 集合 ### epoll(Linux 特有,重点) ```c // 1. 创建 epoll 实例 int epfd = epoll_create1(0); // 2. 注册感兴趣的 fd struct epoll_event ev; ev.events = EPOLLIN; ev.data.fd = listen_fd; epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev); // 3. 等待事件 struct epoll_event events[MAX_EVENTS]; while (true) { int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1); for (int i = 0; i < nfds; i++) { if (events[i].data.fd == listen_fd) { // 新连接 int conn_fd = accept(listen_fd, ...); ev.events = EPOLLIN | EPOLLET; // 边缘触发 ev.data.fd = conn_fd; epoll_ctl(epfd, EPOLL_CTL_ADD, conn_fd, &ev); } else { // 数据可读 handle_read(events[i].data.fd); } } } ``` ### epoll 的实现原理  *图:epoll 用红黑树存 fd、就绪链表返回就绪事件* ``` ┌─────────────────────────────────────┐ │ epoll 内核实现 │ │ │ │ ┌─────────────────────────────┐ │ │ │ 红黑树(存储所有监控的 fd) │ │ │ │ │ │ │ │ fd1 ── fd2 ── fd3 │ │ │ │ \ | / │ │ │ │ fd4 fd5 fd6 │ │ │ └──────────┬──────────────────┘ │ │ │ 事件就绪时移入 │ │ ┌──────────▼──────────────────┐ │ │ │ 就绪链表(rdllist) │ │ │ │ │ │ │ │ fd2 → fd5 → fd6 │ │ ← epoll_wait 只返回这个链表 │ └─────────────────────────────┘ │ └─────────────────────────────────────┘ 1. epoll_ctl(ADD):将 fd 加入红黑树,注册回调函数 2. 当 fd 就绪时,回调函数将 fd 加入就绪链表 3. epoll_wait:检查就绪链表,有就绪 fd 则返回 → 不需要遍历所有 fd,O(1) 获取就绪事件 ``` ### 触发模式 ``` 水平触发(Level Triggered, LT)— 默认模式: 只要 fd 的缓冲区有数据可读,epoll_wait 就会返回该 fd 没读完下次还会通知 类似 select/poll 的行为 边缘触发(Edge Triggered, ET): 只在 fd 状态变化时通知一次(从无数据变为有数据) 必须一次性读完所有数据(循环读直到 EAGAIN) 性能更高,但编程更复杂 ET 模式的正确用法: 1. 设置 fd 为非阻塞 2. 收到事件后循环读取直到 EAGAIN ``` ```c // ET 模式读取 void handle_read(int fd) { char buf[4096]; while (true) { ssize_t n = read(fd, buf, sizeof(buf)); if (n > 0) { process(buf, n); } else if (n == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { break; // 数据读完了 } perror("read error"); break; } else { // n == 0, 连接关闭 close(fd); break; } } } ``` ### select / poll / epoll 对比 | 特性 | select | poll | epoll | |------|--------|------|-------| | fd 上限 | 1024 | 无限制 | 无限制 | | fd 拷贝 | 每次全量拷贝 | 每次全量拷贝 | 注册时拷贝一次 | | 就绪检测 | 遍历 O(n) | 遍历 O(n) | 回调 O(1) | | 触发模式 | LT | LT | LT + ET | | 适用场景 | 连接数少 | 连接数少 | 高并发(万级连接) | ## 4. 信号驱动 I/O  *图:信号驱动 I/O:SIGIO 通知就绪仍需 recvfrom* ``` 用户进程 内核 │ │ │── sigaction(SIGIO) ───→│ 注册信号处理函数 │←── 返回 ───────────────│ │ │ │ 继续做其他事 │ 等待数据... │ │ 数据到达 │←── SIGIO 信号 ─────────│ │ │ │── recvfrom() ─────────→│ │ │ 拷贝数据 │←── 返回数据 ───────────│ ``` 实际使用较少,信号处理复杂且不可靠。 ## 5. 异步 I/O(AIO)  *图:异步 I/O:内核拷贝完成后才通知用户进程* ``` 用户进程 内核 │ │ │── aio_read() ─────────→│ │←── 立即返回 ───────────│ │ │ 等待数据... │ 继续做其他事 │ 数据到达 │ │ 拷贝数据到用户空间 │←── 信号/回调通知 ──────│ 全部完成后才通知 │ │ ``` ```c // POSIX AIO struct aiocb cb; memset(&cb, 0, sizeof(cb)); cb.aio_fildes = fd; cb.aio_buf = buffer; cb.aio_nbytes = 4096; cb.aio_offset = 0; aio_read(&cb); // 立即返回 // 等待完成 while (aio_error(&cb) == EINPROGRESS) { // 做其他事 } ssize_t n = aio_return(&cb); ``` 真正的异步 I/O:两个阶段都不阻塞用户进程。 Linux 的 AIO 实现: - POSIX AIO(glibc):用户态线程池模拟,不是真正的内核异步 - Linux Native AIO(io_submit):内核级异步,但限制多(只支持 O_DIRECT) - io_uring(Linux 5.1+):新一代异步 I/O,真正高性能 ## io_uring(现代 Linux 异步 I/O)  *图:io_uring 的 SQ/CQ 共享内存环与内核级异步* ``` ┌─────────────────────────────────────┐ │ io_uring 架构 │ │ │ │ 用户空间 共享内存 │ │ ┌──────┐ ┌──────────────┐ │ │ │应用 │───→│ SQ(提交队列)│ │ 用户写入 I/O 请求 │ │程序 │ └──────┬───────┘ │ │ │ │ │ │ │ │ │ ┌──────▼───────┐ │ │ │ │←──│ CQ(完成队列)│ │ 内核写入完成事件 │ └──────┘ └──────────────┘ │ │ ↕ │ │ 内核空间 │ │ ┌─────────────────────────────┐ │ │ │ io_uring 内核处理 │ │ │ │ 无需系统调用即可提交/获取 │ │ │ └─────────────────────────────┘ │ └─────────────────────────────────────┘ 优势: 1. 共享内存环形缓冲区,减少系统调用 2. 支持批量提交和批量完成 3. 支持所有 I/O 类型(文件、网络、定时器等) 4. 真正的内核级异步 ``` ## 五种模型总结 ``` 阶段1(等待数据) 阶段2(拷贝数据) 阻塞 I/O 阻塞 阻塞 非阻塞 I/O 非阻塞(轮询) 阻塞 I/O 多路复用 阻塞(在select上) 阻塞 信号驱动 I/O 非阻塞(信号通知) 阻塞 异步 I/O 非阻塞 非阻塞 前四种都是同步 I/O(阶段 2 阻塞) 只有异步 I/O 是真正的异步(两个阶段都不阻塞) ``` ## 本章小结 - 阻塞/非阻塞关注的是等待数据时进程是否挂起 - 同步/异步关注的是数据拷贝时进程是否参与 - epoll 是 Linux 高并发网络编程的基石 - io_uring 是 Linux 异步 I/O 的未来方向 - 理解 I/O 模型是理解 Nginx、Redis、Netty 等高性能框架的基础 ## 思考题 1. 为什么 epoll 的 ET 模式比 LT 模式性能更高? 2. Nginx 使用的是哪种 I/O 模型?Redis 呢? > 💬 **Q:给出这两道思考题的答案** > > **1. 为什么 ET 比 LT 性能更高?** > > ``` > LT(水平触发):缓冲区有数据 → 每次 epoll_wait 都通知你"可读" > → 如果你没一次读完,下次还会通知 → 重复通知多,系统调用开销大 > > ET(边缘触发):只在状态变化时通知一次(无数据 → 有数据) > → 之后不再通知 → epoll_wait 返回次数少,开销小 > ``` > > ET 的代价:必须一次性把数据读完(循环 read 直到返回 EAGAIN),否则剩余数据不会再被通知,编程复杂度更高。 > > 实际性能差距:在连接数少的场景差别不大,在 10 万+ 并发连接时 ET 的优势才明显(减少了大量无效的 epoll_wait 返回)。 > > **2. Nginx 和 Redis 的 I/O 模型** > > | | Nginx | Redis | > |--|-------|-------| > | 架构 | 多进程(master + worker) | 单线程(6.0 后网络 I/O 多线程) | > | I/O 多路复用 | epoll(Linux) | epoll(Linux) | > | 触发模式 | ET(边缘触发) | LT(水平触发) | > | 为什么这样选 | 多 worker 进程处理海量连接,ET 减少系统调用 | 单线程每次事件循环都处理完就绪 fd,LT 的重复通知不是问题,且编程更简单不易出 bug | > > 一句话:Nginx 追求极致网络性能所以用 ET,Redis 的瓶颈不在网络而在内存操作,LT 够用且更安全。 --- 上一篇:[03 - 内核 I/O 栈](./03-kernel-io-stack.md) | 下一篇:[05 - 零拷贝与高性能 I/O](./05-zero-copy.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入