知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 05 - 零拷贝与高性能 I/O ## 传统数据传输的问题 将文件通过网络发送给客户端(如 Web 服务器发送静态文件): ```c // 传统方式 char buf[4096]; int file_fd = open("file.txt", O_RDONLY); read(file_fd, buf, sizeof(buf)); // 从文件读到用户缓冲区 write(socket_fd, buf, sizeof(buf)); // 从用户缓冲区写到 socket ``` ### 传统方式的数据流  *图:read+write 的 4 次数据拷贝与 4 次上下文切换* ``` 4 次数据拷贝 + 4 次上下文切换 用户空间 内核空间 ┌──────────────┐ │ 内核读缓冲区 │ │ (Page Cache) │ └──────┬───────┘ │ ② CPU 拷贝 ┌──────────────┐ │ │ 用户缓冲区 │←───────┘ │ (buf[4096]) │ └──────┬───────┘ │ ③ CPU 拷贝 ┌──────▼───────┐ │ Socket 缓冲区 │ └──────┬───────┘ │ ④ DMA 拷贝 ┌──────▼───────┐ │ 网卡 │ └──────────────┘ ① DMA 拷贝:磁盘 → 内核读缓冲区 ② CPU 拷贝:内核读缓冲区 → 用户缓冲区 ← 多余 ③ CPU 拷贝:用户缓冲区 → Socket 缓冲区 ← 多余 ④ DMA 拷贝:Socket 缓冲区 → 网卡 上下文切换: read() → 用户态→内核态 → 内核态→用户态 write() → 用户态→内核态 → 内核态→用户态 共 4 次 ``` 核心问题:数据在用户空间走了一个来回,完全没有被修改,纯粹浪费。 ## mmap + write ```c // 用 mmap 替代 read void *addr = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, file_fd, 0); write(socket_fd, addr, file_size); munmap(addr, file_size); ```  *图:mmap+write 省掉用户空间拷贝,仍需 4 次上下文切换* ``` 3 次数据拷贝 + 4 次上下文切换 用户空间 内核空间 ┌──────────────┐ │ │ 内核读缓冲区 │ │ mmap 映射 ───→│ (Page Cache) │ │ └──────┬───────┘ │ │ ② CPU 拷贝 │ ┌──────▼───────┐ │ │ Socket 缓冲区 │ │ └──────┬───────┘ │ │ ③ DMA 拷贝 │ ┌──────▼───────┐ │ │ 网卡 │ │ └──────────────┘ ① DMA 拷贝:磁盘 → 内核读缓冲区(Page Cache) ② CPU 拷贝:内核读缓冲区 → Socket 缓冲区 ③ DMA 拷贝:Socket 缓冲区 → 网卡 省掉了用户空间的拷贝(3 次拷贝 vs 4 次) 但仍有 4 次上下文切换 ``` mmap 的特点: - 将文件映射到进程的虚拟地址空间 - 读写映射区域等于读写文件 - 适合随机访问大文件(如数据库索引) - Kafka 的索引文件使用 mmap ```c // mmap 的典型用法 int fd = open("data.bin", O_RDWR); struct stat st; fstat(fd, &st); // 映射整个文件 void *map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // 像操作内存一样操作文件 int *data = (int *)map; data[0] = 42; // 直接写入文件 // 强制刷盘 msync(map, st.st_size, MS_SYNC); // 解除映射 munmap(map, st.st_size); close(fd); ``` ## sendfile(真正的零拷贝) ```c #include <sys/sendfile.h> // 直接在内核中将文件数据发送到 socket sendfile(socket_fd, file_fd, &offset, count); ``` ### Linux 2.1 的 sendfile  *图:sendfile 数据不经过用户空间的 3 次拷贝* ``` 3 次数据拷贝 + 2 次上下文切换 用户空间 内核空间 ┌──────────────┐ │ 内核读缓冲区 │ │ (Page Cache) │ └──────┬───────┘ │ ② CPU 拷贝 ┌──────▼───────┐ │ Socket 缓冲区 │ └──────┬───────┘ │ ③ DMA 拷贝 ┌──────▼───────┐ │ 网卡 │ └──────────────┘ ① DMA 拷贝:磁盘 → Page Cache ② CPU 拷贝:Page Cache → Socket 缓冲区 ③ DMA 拷贝:Socket 缓冲区 → 网卡 数据完全不经过用户空间 只有 2 次上下文切换(sendfile 一次系统调用) ``` ### Linux 2.4+ 的 sendfile(带 DMA Scatter/Gather)  *图:sendfile+SG-DMA 实现零 CPU 拷贝的 2 次拷贝* ``` 2 次数据拷贝 + 2 次上下文切换(真正的零 CPU 拷贝) 用户空间 内核空间 ┌──────────────┐ │ 内核读缓冲区 │ │ (Page Cache) │ └──────┬───────┘ │ 只传递描述符 ┌──────▼───────┐ │ Socket 缓冲区 │ 只存储数据的位置和长度 │ (fd, offset, │ 不拷贝实际数据 │ length) │ └──────┬───────┘ │ ② DMA Gather ┌──────▼───────┐ │ 网卡 │ DMA 直接从 Page Cache 读取 └──────────────┘ ① DMA 拷贝:磁盘 → Page Cache ② DMA Gather:Page Cache → 网卡(根据描述符直接读取) CPU 完全不参与数据拷贝 需要网卡支持 DMA Scatter/Gather(现代网卡都支持) ``` ### 谁在用 sendfile ``` Kafka:消费者拉取消息时使用 sendfile Java 中对应 FileChannel.transferTo() Nginx:发送静态文件时使用 sendfile 配置:sendfile on; Tomcat:发送静态资源时可选 sendfile ``` ## splice ```c // splice:在两个 fd 之间移动数据,不经过用户空间 // 至少一端必须是管道(pipe) ssize_t splice(int fd_in, off_t *off_in, int fd_out, off_t *off_out, size_t len, unsigned int flags); ``` ``` 文件 → 管道 → Socket(两次 splice 调用) int pipefd[2]; pipe(pipefd); // 文件 → 管道 splice(file_fd, &offset, pipefd[1], NULL, len, SPLICE_F_MOVE); // 管道 → Socket splice(pipefd[0], NULL, socket_fd, NULL, len, SPLICE_F_MOVE); ``` splice 的优势: - 比 sendfile 更通用(sendfile 只能文件→socket) - 可以在任意两个 fd 之间传输(通过管道中转) - HAProxy 使用 splice 进行代理转发 ## 各种零拷贝方式对比  *图:五种零拷贝方式的 CPU 拷贝与上下文切换对比* ``` 方式 CPU拷贝 DMA拷贝 上下文切换 适用场景 ───────────────────────────────────────────────────── read + write 2 2 4 通用 mmap + write 1 2 4 随机访问大文件 sendfile 1 2 2 文件→socket sendfile(SG-DMA) 0 2 2 文件→socket(最优) splice 0 2 2 任意fd间传输 ``` ## Java 中的零拷贝 ### FileChannel.transferTo() ```java // 底层调用 sendfile FileChannel fileChannel = FileChannel.open(Paths.get("file.txt")); SocketChannel socketChannel = SocketChannel.open( new InetSocketAddress("localhost", 8080)); // 零拷贝传输 long transferred = fileChannel.transferTo(0, fileChannel.size(), socketChannel); ``` ### MappedByteBuffer(mmap) ```java // 底层调用 mmap FileChannel channel = FileChannel.open(Paths.get("data.bin"), StandardOpenOption.READ, StandardOpenOption.WRITE); MappedByteBuffer buffer = channel.map( FileChannel.MapMode.READ_WRITE, 0, channel.size()); // 像操作内存一样操作文件 buffer.putInt(0, 42); buffer.force(); // 强制刷盘 ``` ### DirectByteBuffer ```java // 堆外内存,减少一次 JVM 堆到 native 内存的拷贝 ByteBuffer directBuffer = ByteBuffer.allocateDirect(4096); // 普通 HeapByteBuffer 的写入路径: // 用户数据 → JVM 堆 → native 内存 → 内核缓冲区 → 设备 // DirectByteBuffer 的写入路径: // 用户数据 → native 内存(堆外)→ 内核缓冲区 → 设备 // 少了一次 JVM 堆到 native 内存的拷贝 // Netty 大量使用 DirectByteBuffer ``` ## 直接 I/O(Direct I/O) 绕过 Page Cache,直接在用户缓冲区和磁盘之间传输。 ```c // O_DIRECT 标志 int fd = open("file.txt", O_RDWR | O_DIRECT); // 要求: // 1. 缓冲区地址必须对齐(通常 512 字节或 4KB) // 2. 读写大小必须是扇区大小的整数倍 // 3. 文件偏移必须对齐 void *buf; posix_memalign(&buf, 4096, 4096); // 4KB 对齐 read(fd, buf, 4096); ``` ``` 普通 I/O: 应用 ←→ Page Cache ←→ 磁盘 直接 I/O: 应用 ←→ 磁盘(绕过 Page Cache) 适用场景: 数据库(自己管理缓存,如 MySQL InnoDB) 大文件顺序读写(避免污染 Page Cache) 不适用场景: 小文件随机读写(Page Cache 命中率高时更快) 需要 OS 缓存加速的场景 ``` ## 本章小结 - 传统 I/O 有 4 次拷贝和 4 次上下文切换 - sendfile 是最高效的文件→网络传输方式(2 次 DMA 拷贝,0 次 CPU 拷贝) - mmap 适合随机访问大文件,避免了用户空间的数据拷贝 - 直接 I/O 绕过 Page Cache,适合自己管理缓存的应用 - 理解零拷贝是理解 Kafka、Nginx、Netty 高性能的关键 ## 思考题 1. Kafka 为什么同时使用了 mmap(索引)和 sendfile(数据传输)? 2. 数据库为什么通常使用 Direct I/O 而不是依赖 Page Cache? --- 上一篇:[04 - I/O 模型详解](./04-io-models.md) | 下一篇:[06 - 磁盘 I/O 调度与优化](./06-disk-scheduling.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入