知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 操作系统 & IO 高频面试题集(35 题) 按主题分五章,覆盖进程线程、内存、文件系统、IO 模型、Linux 实战。 ## 目录 - [第 1 章 · 进程与线程(8 题)](#第-1-章--进程与线程) - [第 2 章 · 内存管理(6 题)](#第-2-章--内存管理) - [第 3 章 · IO 模型(8 题)](#第-3-章--io-模型) - [第 4 章 · 文件系统与存储(5 题)](#第-4-章--文件系统与存储) - [第 5 章 · Linux 实战(8 题)](#第-5-章--linux-实战) ## 高频 Top 10 1. 进程和线程的区别?(1) 2. 进程间通信方式(IPC)?(4) 3. 五种 IO 模型?(17) 4. select / poll / epoll 的区别?(18-19) 5. Reactor 模式?(22) 6. 零拷贝?(23) 7. 虚拟内存和物理内存?分页?(10) 8. 用户态和内核态?(3) 9. 怎么查看系统负载?(28-30) 10. 死锁四个条件?(8) --- # 第 1 章 · 进程与线程 ## 1. 进程和线程的区别? | 对比 | 进程 | 线程 | |------|------|------| | 定义 | 程序执行的基本单元 | 进程内的执行流 | | 资源 | 独立地址空间 | 共享进程资源 | | 通信 | IPC(管道、共享内存、消息队列等) | 共享内存直接通信 | | 切换开销 | 大(切地址空间) | 小(共享地址空间) | | 创建开销 | 大 | 小 | | 稳定性 | 进程崩溃不影响其他 | 线程崩溃可能影响整个进程 | ## 2. 协程是什么? **协程(Coroutine)**:比线程更轻量的执行单元,用户态调度,不涉及内核。 **特点**: - 一个线程内可以跑**上万协程** - **同步代码写异步逻辑**(suspend / resume) - 切换开销极小 **代表**: - Go 的 goroutine - Python 的 async/await - Kotlin 的 coroutine - Java 的虚拟线程(JDK 21+) > 💬 **Q:协程的出现解决了什么问题?为什么要有协程?** > > 协程本质上解决的是**线程太重**的问题。 > > **线程的痛点**: > > 1. **创建/销毁开销大**:每个线程默认 1MB 栈 + 内核数据结构 > 2. **切换开销大**:用户态 → 内核态 → 保存/恢复寄存器(微秒级) > 3. **数量有限**:一台机器几千个线程就到极限了 > 4. **高并发 IO 场景浪费**:线程大部分时间在等 IO,等的时候啥也不干但占着资源 > > **协程怎么解决**: > > | 维度 | 线程 | 协程 | > |------|------|------| > | 栈大小 | 1MB(固定) | 几 KB(动态增长) | > | 切换 | 内核态切换(微秒) | 用户态切换(纳秒) | > | 数量 | 几千 | **几十万甚至百万** | > | 调度 | OS 内核调度 | 用户态运行时调度 | > | 编程模型 | 回调/异步复杂 | **同步写法,异步执行** | > > **核心价值**: > > - **高并发 IO 密集场景**(Web 服务器、网关、微服务):一个请求一个协程,百万并发轻松 > - **代码简洁**:不用写回调地狱,用同步的方式写异步逻辑 > > **举个例子**: > > ```go > // Go 的 goroutine:一个 HTTP 服务轻松处理 10 万并发连接 > func handler(w http.ResponseWriter, r *http.Request) { > result := queryDB() // 看起来是同步的,实际底层是异步 IO > w.Write(result) // 等 IO 时协程挂起,让出 CPU 给其他协程 > } > ``` > > 如果用线程:10 万连接 = 10 万线程 = 100GB 栈内存,直接炸。 > 如果用协程:10 万连接 = 10 万协程 = 几百 MB,轻松。 > > **一句话总结**:协程 = 用户态的轻量级线程,解决了"高并发 IO 场景下线程太重、太贵、太少"的问题。 ## 3. 用户态和内核态? **用户态(User Mode)**:应用程序运行的级别,权限低,不能直接访问硬件 **内核态(Kernel Mode)**:OS 内核运行的级别,可以做任何事 **切换时机**: - 系统调用(`open`、`read`、`write`) - 异常(缺页) - 中断(硬件、时钟) **切换开销**:保存寄存器、刷 TLB 等,毫秒级。 ## 4. 进程间通信(IPC)方式? 1. **管道(Pipe)**:匿名管道(父子进程)、命名管道(FIFO,任意进程) 2. **消息队列**:内核维护的消息链表 3. **共享内存**:最快(直接内存访问),需要配合信号量同步 4. **信号量**:计数器,用于同步 5. **信号**:异步通知(SIGINT、SIGTERM) 6. **socket**:跨主机通信 7. **Unix Domain Socket**:本机进程间,比 TCP 快 ## 5. 线程同步方式? 1. **互斥锁(Mutex)**:同时只能一个线程访问 2. **读写锁(RWLock)**:多读单写 3. **自旋锁(Spinlock)**:忙等(适合锁持有时间极短的场景) 4. **信号量(Semaphore)**:计数 5. **条件变量(Condition Variable)**:配合 Mutex 使用 6. **屏障(Barrier)**:多线程到达同一点后继续 7. **原子操作**:无锁(CAS) ## 6. 进程的状态? 五态模型:  *图:进程五状态流转与时间片用完后的回退* ``` 创建 → 就绪 → 运行 → 阻塞 → 终止 ↑ ↓ └──────┘(时间片用完、被抢占) ``` Linux 的状态(`ps` 看): - **R**(Running):运行 / 可运行 - **S**(Sleeping):可中断睡眠 - **D**(Disk Sleep):不可中断睡眠(等 IO) - **T**(Stopped):停止 - **Z**(Zombie):僵尸(子进程退出,父进程没 wait) - **X**:退出 ## 7. 僵尸进程和孤儿进程? **僵尸进程**:子进程退出了,父进程还没调 `wait()` 回收 → 子进程的 PCB 还在 **孤儿进程**:父进程先退出,子进程被 `init`(pid 1)收养 **问题**:僵尸进程占用 PID。防止方法: - 父进程及时 `wait()` / `waitpid()` - 忽略 SIGCHLD:`signal(SIGCHLD, SIG_IGN)` ## 8. 死锁的四个必要条件? 1. **互斥**:资源不能共享 2. **请求与保持**:持有资源的同时申请新资源 3. **不剥夺**:资源只能主动释放 4. **循环等待**:等待链成环 **避免**:破坏任一条件 - 一次性申请所有资源(破坏 2) - 固定顺序申请(破坏 4,最常用) - 超时释放(tryLock + timeout) --- # 第 2 章 · 内存管理 ## 9. 虚拟内存是什么? **虚拟内存**:每个进程有独立的**虚拟地址空间**(32 位系统 4GB,64 位 256TB 理论) **好处**: - 进程隔离(各自的虚拟地址互不干扰) - 程序可以比物理内存大(通过 swap) - 便于内存分配(连续的虚拟地址,物理地址可以不连续) **映射**:虚拟地址 → 物理地址,通过**页表**实现。 ## 10. 分页和分段? **分页**(现代 OS 用): - 内存分成固定大小的**页**(通常 4KB) - 按需加载(缺页中断) - 解决碎片化 **分段**: - 按逻辑划分(代码段、数据段、栈段) - 段大小可变 - 内部碎片少,外部碎片多 **现在**:基本都是**分页**,段只作为逻辑概念(代码段、数据段只是 ELF 文件的分节)。 ## 11. 缺页中断? **现象**:访问的虚拟地址对应的物理页不在内存 **处理**: 1. 发起缺页中断 2. 内核检查是合法访问(不是越界) 3. 从磁盘加载页到内存 4. 更新页表 5. 重试失败的指令 **带来的影响**:磁盘 IO,延迟大。频繁缺页说明内存不足(swap 严重)。 ## 12. 内存分配算法? **堆内存分配**(malloc、jemalloc、tcmalloc): - **首次适应**:找第一个够大的块 - **最佳适应**:找最小的够大块 - **伙伴系统**(buddy system):Linux 内核用 - **slab 分配器**:针对小对象优化 **现代分配器**(tcmalloc、jemalloc)都是多层 + 线程本地缓存,性能很高。 ## 13. 内存泄漏 vs 内存溢出? - **内存泄漏(Memory Leak)**:分配的内存没有释放,积累导致可用内存越来越少 - **内存溢出(Out of Memory)**:需要的内存超过可用内存 **内存泄漏工具**:Valgrind(C/C++)、MAT(Java) ## 14. 写时复制(COW)? **Copy-On-Write**:多个进程/对象共享同一份内存,**只有写时才复制**。 **应用**: - `fork()`:父子进程共享内存页,只在写时复制 - Java 的 `CopyOnWriteArrayList` - Redis 的 BGSAVE / BGREWRITEAOF ## 15. 大页(Huge Page)? **普通页**:4KB **大页**:2MB 或 1GB **好处**: - 减少 TLB miss(一个 TLB 项覆盖更多内存) - 减少页表层级 **坑**: - **Transparent Huge Pages (THP)** 在某些场景(Redis、MongoDB)反而拖慢,因为 COW 复制整个大页代价高 - **生产建议**:数据库和缓存关闭 THP --- ## 16. 什么是 IO? **IO** = Input / Output,指程序和外部(磁盘、网络)的数据交换。 **流程**(以网络读为例): 1. **等待数据到达内核**(网卡 → 内核 socket buffer) 2. **数据从内核拷贝到用户空间** IO 模型的区别就在于**这两步怎么处理**。 ## 17. 五种 IO 模型? **1. 阻塞 IO(Blocking IO)** - 调用 `read` → 阻塞直到数据到达 → 拷贝 → 返回 - 最简单,但并发差 **2. 非阻塞 IO(Non-blocking IO)** - `read` 立即返回(要么有数据要么 EAGAIN) - 需要**轮询**,CPU 浪费 **3. IO 多路复用(IO Multiplexing)** - `select`/`poll`/`epoll`:**一个线程监听多个 fd** - 有 fd 就绪就通知,然后再 `read` - 高并发场景的主流 **4. 信号驱动 IO(Signal Driven IO)** - 注册信号处理函数,数据到达发 SIGIO - 用得少 **5. 异步 IO(Asynchronous IO)** - 发起读请求立即返回 - 内核把数据拷贝好后通知 - **真正的异步**,Linux 的 AIO、Windows 的 IOCP、io_uring ## 18. select、poll、epoll 的区别? | 对比 | select | poll | epoll | |------|--------|------|-------| | fd 数量 | 1024(FD_SETSIZE) | 无限制 | 无限制 | | 数据结构 | bitmap | 数组 | 红黑树 + 链表 | | 每次调用 | 传入所有 fd | 传入所有 fd | 只关心就绪的 | | 查找就绪 | O(n) | O(n) | O(1) | | 内核→用户 | 每次拷贝所有 fd | 每次拷贝所有 fd | 只拷贝就绪的 | | 触发方式 | LT(水平触发) | LT | LT + ET(边缘触发) | | 跨平台 | 有 | 有 | Linux only | **epoll 为什么快**: 1. 就绪列表直接返回,不用遍历 2. 用 mmap 减少内核/用户态拷贝 3. 支持 ET(边缘触发)进一步减少触发次数 ## 19. epoll 的 LT 和 ET 模式? **LT(Level Triggered)水平触发**(默认): - 数据可读就一直通知,没读完下次 epoll 还会通知 - 容易使用,不会丢事件 **ET(Edge Triggered)边缘触发**: - 只在**状态变化时通知一次**(从不可读变可读) - 必须**一次读完所有数据**(while 循环 read 到 EAGAIN) - 配合**非阻塞 IO** 使用 **ET 的优势**:减少事件通知次数,效率更高。Nginx、Redis 用 ET。 ## 20. 同步 IO vs 异步 IO? **同步 IO**:应用自己负责数据拷贝(从内核到用户态),调用会阻塞 - 包括:阻塞 IO、非阻塞 IO、IO 多路复用、信号驱动 **异步 IO**:内核帮应用完成整个 IO(包括拷贝),应用只需要注册回调 - Windows IOCP、Linux io_uring **注意**:IO 多路复用(epoll)虽然名字里有"多路",但还是同步 IO。应用自己调用 `read`,`read` 本身是同步的。 ## 21. BIO / NIO / AIO(Java)? - **BIO(Blocking IO)**:`java.io.*`,一个连接一个线程 - **NIO(Non-blocking IO)**:`java.nio.*`,基于 Channel + Buffer + Selector,用 IO 多路复用实现 - **AIO(Asynchronous IO)**:`java.nio.channels.AsynchronousXxx`,真正的异步(Linux 底层是模拟的,Windows 是 IOCP) **实际**: - Java 生态主流是 NIO(Netty、Tomcat) - AIO 在 Linux 上并没有显著优势,没大规模应用 ## 22. Reactor 模式? **Reactor(反应器模式)**:基于事件驱动的 IO 多路复用 **单 Reactor 单线程**: ``` Reactor 监听所有事件 → 事件分发给 Handler 处理(都在同一线程) ``` 适合连接少、业务简单。 **单 Reactor 多线程**: ``` Reactor 监听事件 → 分发到工作线程池处理业务 ``` **主从 Reactor**(Netty 默认): ``` Boss Reactor:处理连接(accept) Worker Reactor 池:处理 IO 读写 业务处理:独立线程池 ``` 适合高并发场景。 ## 23. 零拷贝? **传统 read + send**: ``` 磁盘 → DMA → 内核 buffer → CPU 拷贝 → 用户 buffer → CPU 拷贝 → 内核 socket buffer → DMA → 网卡 (4 次拷贝,2 次上下文切换) ``` **sendfile(零拷贝)**: ``` 磁盘 → DMA → 内核 buffer → DMA → 网卡 (2 次拷贝,0 次 CPU 拷贝) ``` **mmap + write**: ``` 磁盘 → DMA → 内核 buffer(直接映射到用户空间)→ CPU 拷贝 → socket buffer → DMA → 网卡 (3 次拷贝,减少一次) ``` **应用**:Kafka、Nginx、Netty 静态文件传输。 > 💬 **Q:举例用大白话说清楚零拷贝技术** > > 用一个生活例子来说: > > **场景**:你开了个网盘服务,用户要下载文件。程序需要"从磁盘读文件 → 发到网络"。 > > **传统方式(没有零拷贝)**: > > 想象你是快递员,要把仓库(磁盘)里的货物送到客户(网卡)手上: > > ``` > 1. 仓库管理员把货物搬到前台(磁盘 → 内核缓冲区) > 2. 你从前台搬到自己的车上(内核 → 用户空间) ← CPU 搬运 > 3. 你再从车上搬到快递站(用户空间 → 内核 socket 缓冲区) ← CPU 搬运 > 4. 快递站发出去(socket 缓冲区 → 网卡) > ``` > > **问题**:你(CPU)来回搬了两趟,累死了。而且货物在你车上的时候(用户空间),你根本没拆开看,只是过了个手。 > > **零拷贝方式(sendfile)**: > > ``` > 1. 仓库管理员把货物搬到前台(磁盘 → 内核缓冲区) > 2. 前台直接叫快递来取(内核缓冲区 → 网卡) > ``` > > **你(CPU)根本不用参与搬运**!货物从仓库出来后直接发走了,不经过你的车(用户空间)。 > > **为什么叫"零拷贝"**: > > - 不是说完全没有数据移动(磁盘到内存、内存到网卡还是要的) > - 而是 **CPU 不用亲自搬数据**(零次 CPU 拷贝),全靠 DMA(硬件直接搬) > - 数据**不经过用户空间**,省了两次无意义的搬运 > > **Kafka 消费者读消息就是这个原理**: > > ``` > Consumer 请求消息 > → Broker 调用 sendfile() > → 磁盘上的消息文件直接从 Page Cache 发到网卡 > → 不经过 Broker 的 Java 堆 > → 所以 Kafka 消费吞吐极高 > ``` > > **Java 代码**:`FileChannel.transferTo()` 底层就是 `sendfile`。 > > **限制**: > > - 如果要加密(SSL/TLS),必须经过用户态加密,零拷贝失效 > - 如果要修改数据内容(压缩/转码),也必须经过用户态 --- # 第 4 章 · 文件系统与存储 ## 24. inode 和 dentry? **inode**:文件的元信息(大小、权限、时间戳、数据块位置),**不含文件名** **dentry**(目录项):文件名 → inode 的映射 一个 inode 可以对应多个文件名(**硬链接**)。 ## 25. 硬链接 vs 软链接? - **硬链接**:多个文件名指向**同一个 inode** - 不能跨文件系统 - 不能对目录 - 删除源文件,硬链接依然有效 - **软链接(符号链接)**:独立文件,内容是目标路径 - 可以跨文件系统 - 可以对目录 - 源文件删了,软链接失效(悬垂链接) ## 26. 文件读写的 Page Cache? **Page Cache**:OS 把磁盘数据缓存到内存 - 读:先查 Page Cache,命中直接返回 - 写:先写 Page Cache 标记脏页,异步刷盘(`sync`、`fsync` 强制刷盘) **好处**:极大减少磁盘 IO **代价**:断电会丢最近写的数据(除非调 `fsync`) ## 27. 磁盘 IO 慢在哪? **机械硬盘(HDD)**: - **寻道时间**:磁头移动(10ms 级) - **旋转时间**:等盘片转到位 - **传输时间**:读数据 - **随机 IO 比顺序 IO 慢几十倍** **SSD**: - 没有机械移动,随机和顺序差距小 - 但**写放大**、**GC** 问题 **优化方向**: - 顺序 IO(Kafka 就是这么做的) - 批量操作 - 异步 IO - Page Cache ## 28. RAID 是什么? 多磁盘组合,提高性能或可靠性: - **RAID 0**:条带化,性能高,无冗余 - **RAID 1**:镜像,冗余 - **RAID 5**:条带 + 奇偶校验(最少 3 盘,坏 1 盘能恢复) - **RAID 6**:双奇偶校验(最少 4 盘,坏 2 盘能恢复) - **RAID 10**:先镜像再条带(性能 + 冗余) 生产数据库通常用 RAID 10 或 RAID 5。 --- # 第 5 章 · Linux 实战 ## 29. top 的关键指标? ``` top - 12:00:00 up 10 days, ... load average: 0.50, 0.40, 0.30 ← 1、5、15 分钟平均负载 Tasks: 200 total, ... %Cpu(s): 10.0 us, 5.0 sy, 0.0 ni, 85.0 id, 0.0 wa, 0.0 hi, 0.0 si ``` **CPU 字段**: - `us`:用户态 CPU - `sy`:内核态 CPU - `id`:空闲 - `wa`:等 IO(高说明磁盘瓶颈) - `hi/si`:硬中断 / 软中断 **负载**:CPU 队列长度 - 负载 > CPU 核数 说明任务堆积 ## 30. CPU 100% 排查? ```bash top # 看哪个进程 CPU 高 top -Hp <PID> # 进程内哪个线程 CPU 高 pidstat -t -p <PID> 1 # 同上 perf top # 系统级热点函数 ``` **Java 场景**:`jstack` 查线程栈(见 JVM 章节) ## 31. 内存占用排查? ```bash free -h # 总览 top / ps aux --sort=-%mem # 按内存排序 pmap -x <PID> # 进程的内存映射 ``` **Linux 的 free 看法**: - `used`:实际使用 - `free`:完全空闲 - `buff/cache`:Page Cache(可回收) - `available`:可用(free + 可回收的 cache) **关键**:看 `available`,不是 `free`。 ## 32. 磁盘 IO 排查? ```bash iostat -x 1 # IO 统计 iotop # 哪个进程 IO 高 df -h # 磁盘使用率 du -sh * # 文件夹大小 ``` **iostat 关键字段**: - `%util`:磁盘繁忙度(100% = 饱和) - `await`:IO 平均等待时间 - `r/s, w/s`:每秒读写次数 ## 33. 网络排查? ```bash ifstat / sar -n DEV 1 # 带宽使用 netstat -antp / ss -antp # 连接状态 netstat -tulpn / ss -tulpn # 监听端口 tcpdump -i eth0 port 80 # 抓包 ``` ## 34. 文件描述符(fd)相关? ```bash ulimit -n # 查看当前限制 ulimit -n 65535 # 临时调整 # /etc/security/limits.conf # 永久配置 lsof -p <PID> # 进程打开的 fd lsof -i :80 # 端口被谁占 ``` **fd 超限**:`Too many open files` → 调大 `ulimit -n`,或修复 fd 泄漏。 ## 35. 定位线上问题的常用排查思路? **四维度排查**(USE 方法论): 1. **CPU**:top / pidstat / perf 2. **内存**:free / ps / pmap 3. **磁盘 IO**:iostat / iotop 4. **网络**:ss / sar / tcpdump **应用层**:日志、监控(Prometheus、ELK)、APM(SkyWalking、Pinpoint) **常见套路**: ``` 1. 看监控:趋势异常? 2. 看日志:有没有错误? 3. 系统指标:CPU/MEM/IO/NET 哪个异常? 4. 定位进程:哪个进程有问题? 5. 定位线程:哪个线程有问题? 6. 分析栈:在做什么? 7. 改代码 / 调参 ``` **生产纪律**:改参数/回滚前要有监控数据支持,不要拍脑袋。 ## 36.什么是 socket 通信? > > **Socket** 是操作系统提供的**网络编程接口**,是应用程序和 TCP/IP 协议栈之间的桥梁。 > > **一句话理解**:Socket = IP 地址 + 端口号,标识网络上的一个通信端点。两个 Socket 建立连接后就能互相收发数据。 > > **类比**:IP 地址 = 你家的小区地址,端口号 = 门牌号,Socket = 一条电话线的两端。 > > **通信流程(TCP)**: > > ``` > 服务端 客户端 > socket() 创建 socket() 创建 > bind() 绑定 IP:端口 > listen() 开始监听 > connect() 发起连接(三次握手) > accept() 接受连接 ←─────────────→ 连接建立 > recv() 读数据 send() 写数据 > send() 写数据 recv() 读数据 > close() 关闭 close() 关闭 > ``` > > **Socket 的本质**:在内核里就是一个**文件描述符(fd)**,读写 Socket 和读写文件一样(Linux "一切皆文件")。 > > **两种 Socket**: > > - **TCP Socket**(SOCK_STREAM):面向连接、可靠、有序 > - **UDP Socket**(SOCK_DGRAM):无连接、不可靠、快 > > **和 IO 模型的关系**:上面第 17 题的五种 IO 模型,说的就是**对 socket fd 的读写方式**——阻塞等、轮询、多路复用、信号驱动、异步,本质都是在操作 socket。 > 💬 **Q:都发到用户态缓冲区了,为什么还要发到内核 socket buffer?** > > 核心原因:**用户态程序没有权限直接操作网卡**,发网络数据必须通过内核。 > > ``` > 用户态(你的 Java/C 程序) > ─────────────────────────── ← 权限边界(系统调用) > 内核态(OS 内核) > ─────────────────────────── ← 硬件边界 > 网卡硬件 > ``` > > - 网卡是**硬件设备**,只有内核有权限操作 > - 你的程序调 `send()` 时,实际上是**把数据交给内核**,让内核帮你发 > - 内核要做很多事:加 TCP 头、IP 头、校验和、分片、重传管理、拥塞控制... > - 这些都在**内核的 socket buffer** 里完成 > > **所以传统流程是这样的**: > > ``` > 1. 磁盘 → 内核 Page Cache(DMA 搬) > 2. 内核 → 用户 buffer(CPU 搬) ← 你的程序拿到数据 > 3. 用户 buffer → 内核 socket buffer(CPU 搬) ← 你调 send(),数据又回到内核 > 4. 内核 socket buffer → 网卡(DMA 搬) ← 内核加完 TCP/IP 头后发出去 > ``` > > **第 2 步和第 3 步就是浪费**:数据从内核出来到用户态,你啥也没改,又原封不动送回内核。来回搬了两趟纯属多余。 > > **零拷贝的思路**:既然你不改数据,那干脆**别经过用户态了**,内核自己从 Page Cache 直接发到 socket buffer 再到网卡。 > > **什么时候必须经过用户态?** > > - 你要**修改数据**(加密、压缩、转码) > - 你要**检查数据**(业务逻辑判断) > > 如果只是"读文件原样发网络"(Kafka 消费、Nginx 静态文件、文件下载),用户态就是多余的中间人,零拷贝直接跳过它。 > 💬 **Q:DMA 拷贝和 CPU 拷贝有什么区别?分别有什么应用场景?** > > 核心区别就一句话:**谁在干搬运的活**。 > > **CPU 拷贝**:CPU 亲自一个字节一个字节搬数据 > > ``` > 内存 A 区域 → CPU 寄存器 → 内存 B 区域 > ``` > > - CPU 全程参与,搬运期间**干不了别的事** > - 类比:你亲自一箱一箱搬家,搬的时候不能做饭、不能工作 > > **DMA 拷贝**:DMA 控制器(专用硬件芯片)搬数据,CPU 只下个命令 > > ``` > CPU 告诉 DMA:"把磁盘 X 位置的数据搬到内存 Y 位置" > DMA 自己搬 → 搬完通知 CPU(中断) > CPU 期间可以做别的事 > ``` > > - CPU 只花一瞬间下指令,**不参与实际搬运** > - 类比:你叫了搬家公司,告诉他们搬哪些东西到哪里,然后你该上班上班 > > **对比**: > > | 维度 | CPU 拷贝 | DMA 拷贝 | > |------|---------|----------| > | 谁搬 | CPU | DMA 控制器(硬件) | > | CPU 占用 | 100%(搬运期间被占满) | 几乎 0(只下命令) | > | 速度 | 快(内存到内存) | 取决于设备速度(磁盘/网卡) | > | 适用 | 内存之间的数据移动 | 设备 ↔ 内存的数据移动 | > > **应用场景**: > > - **DMA 拷贝**(设备 ↔ 内存):磁盘读写、网卡收发、显卡渲染、USB 等所有 IO 设备 > - **CPU 拷贝**(内存 ↔ 内存):内核 buffer ↔ 用户 buffer、`memcpy()`、数组复制 > > **回到零拷贝的语境**: > > ``` > 传统方式: > 磁盘 →[DMA]→ 内核 buffer →[CPU]→ 用户 buffer →[CPU]→ socket buffer →[DMA]→ 网卡 > ↑ ↑ > 这两次是 CPU 拷贝,浪费! > > 零拷贝(sendfile): > 磁盘 →[DMA]→ 内核 buffer →[DMA]→ 网卡 > ↑ > 全程只有 DMA,CPU 不搬数据 > ``` > > **零拷贝的"零"指的就是:零次 CPU 拷贝**。DMA 拷贝还是有的(硬件搬运避免不了),但 CPU 解放了。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入