主题
操作系统
一、操作系统概述与内核基础
1. 什么是操作系统?三大抽象是什么?
Q: 什么是操作系统?它解决了什么问题?
一句话:操作系统是硬件与应用程序之间的中间层,管理硬件资源的分配,并抽象给软件。
三大抽象:
| 抽象概念 | 底层物理资源 | 作用 |
|---|---|---|
| 进程 | CPU | 解决并发和隔离。让多个程序能“同时”运行,互不干扰,每个程序都以为自己独占了整个CPU。 |
| 虚拟内存 | 物理内存 | 将内存隔离,每个进程都有独立、连续、从 0 开始的地址空间 |
| 文件 | 磁盘/外部设备 | 解决持久化存储的易用性。将复杂的硬件块设备,统一抽象成有序的字节流。 |
- OS 本身也是一个程序(C 写),但它是第一个被加载的程序,并且拥有对硬件的完全控制权。
- OS ≠ 内核。内核是 OS 的核心(进程/内存/文件/驱动),OS 还包括 shell、系统库、系统程序。
追问链:
- 没有操作系统行不行?→ 可以,裸机程序直接操作硬件,但没有隔离、没有抽象、无法多任务。
- 操作系统怎么保证程序不搞坏系统?→ 用户态/内核态 + 页表权限 + 特权指令。
2. 为什么要分用户态和内核态?什么时候切换?
Q: 用户态和内核态的区别?为什么要分?
| 内核态(Ring 0) | 用户态(Ring 3) | |
|---|---|---|
| 能执行 | 所有指令,包括特权指令 | 只能执行普通指令 |
| 能访问 | 任意物理内存、I/O 端口、页表 | 只能访问自己的虚拟地址空间 |
目的:隔离与保护。防止应用改内核数据、直接操作硬件、搞崩系统。
用户态 → 内核态的三种方式:
| 类型 | 来源 | 同步/异步 | 例子 |
|---|---|---|---|
| 系统调用 | 程序主动发起 | 同步 | read/write/fork,执行 syscall |
| 异常 | CPU 执行指令内部出错 | 同步 | 缺页、除零、非法指令 |
| 硬件中断 | 外部设备 | 异步 | 时钟、网卡收包、磁盘完成 |
开销构成:特权级切换( Ring 0 到 Ring 3) + 保存/恢复上下文 + 用户栈切内核栈 + 页表/cache 污染,通常几百 ns 到微秒级。
追问链:
所有系统调用都要切态吗?→ 普通 syscall 要;
gettimeofday这类走 vDSO,在用户态读共享页,不陷入内核。陷入内核等于上下文切换吗?→ 不等于。陷入内核只是“模式切换”,而上下文切换是“进程/线程切换”。陷入内核可能会引起上下文切换
陷入内核:
- 本质:CPU 特权级发生改变,从 用户态(Ring 3) 切换到 内核态(Ring 0)。
- 动作:保存极少量的用户态寄存器(比如栈指针、程序计数器),切换到内核栈,开始执行操作系统的代码。
上下文切换:
- 本质:CPU 从一个进程/线程(A) 切换到另一个进程/线程(B)。
- 动作:不仅要保存当前进程 A 的 CPU 寄存器、程序计数器、内存管理信息(页表等),还要加载进程 B 之前保存的状态,同时还要刷新 TLB 缓存等。这是重量级操作。
3. 系统调用的完整流程?为什么比普通函数调用慢?
Q: 以
write为例,讲一下系统调用从用户态到内核态再返回的全过程。
text
用户态:
① 系统调用号放入约定寄存器(rax)
② 参数也放入约定寄存器
③ 执行 syscall 指令
内核态:
④ CPU 切 Ring3 → Ring0,跳到内核固定入口
⑤ 保存用户寄存器,切换内核栈
⑥ 按编号查 sys_call_table,调用 sys_write
⑦ 执行真正的内核逻辑
返回:
⑧ 切回 Ring3
⑨ 返回值放 rax,继续执行用户代码1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
为什么慢:真正工作的代码只有几条指令,代价全在模式切换 + 上下文保存恢复上,外加用户↔内核数据拷贝、cache/TLB 污染。
普通函数调用只是压栈跳转,不换特权级。
减少系统调用的手段:
- 用户态缓冲批量读写;
mmap代替反复read/write;sendfile/splice零拷贝;io_uring批量提交;
追问链:
- 系统调用号是函数地址吗?→ 不是,是索引,内核用它在
sys_call_table里查函数指针。
4. 中断、异常、系统调用(trap)有什么区别?
Q: 中断、异常、陷入分别是什么?
| 中断(Interrupt) | 异常(Exception) | 陷入(Trap) | |
|---|---|---|---|
| 来源 | CPU 外部硬件 | CPU 执行指令内部 | 程序主动触发 |
| 同步性 | 异步,随时可能 | 同步,与当前指令相关 | 同步,时机确定 |
| 例子 | 时钟、网卡、磁盘 I/O 完成 | 缺页(Fault)、除零、非法指令 | 系统调用 |
| 返回后 | 继续执行原指令流 | Fault 修复后重新执行原指令 | 返回下一条指令 |
追问链:
缺页是中断还是异常?→ 异常,处理完要重新执行触发缺页的那条指令。
为什么中断处理要短?→ 中断期间可能关中断/占 CPU,处理太久会丢中断、增加延迟。
「信号(signal)是中断」——错。信号是进程间异步通知,不是硬件中断。
5. 「一切皆文件」是什么意思?/proc 是真文件吗?
Q: 怎么理解 Linux 的「一切皆文件」?
普通文件、目录、管道、socket、进程信息(/proc)、内核参数(/sys)都通过 open/read/write/close 这一套接口访问。
- socket 也是文件吗?→ 是。
fd只是 fd 表下标,struct file->f_op = socket_file_ops,所以read/write/close/poll都能用。 - Socket 并没有在磁盘上分配空间,所以没有磁盘 inode。但是,当你在内核中创建一个 Socket 时,VFS 会在内存中为它分配一个
struct inode,这就是内存 inode。
易错:
/proc不是磁盘上的真实文件;ls -l /proc大小为 0 是正常的。- 「一切皆文件」是接口统一,不代表底层实现相同。
6. 用户态和内核态之间有哪些通信方式?
Q: 用户程序想和内核交换数据,有哪些方式?
| 方式 | 特点 | 场景 |
|---|---|---|
| 系统调用 | 最基础,同步 | 几乎所有内核服务 |
| mmap | 共享页,零拷贝 | 高性能数据交换、共享内存 |
| 信号 | 异步、只传编号 | 内核通知进程(SIGIO、SIGCHLD) |
| Unix Socket | 本机 socket,可传 fd | 用户态服务间通信(通过内核) |
一句话:控制走 syscall,数据走 mmap/共享内存,通知走信号/eventfd。
二、进程与线程
1. 进程和线程的区别?
Q: 进程和线程有什么区别?
一句话:进程是资源分配的基本单位,线程是 CPU 调度的基本单位。
Q:进程和线程在资源上有什么不同? **A:**进程有独立的地址空间、PCB、fd 表、信号处理,是资源分配的基本单位;线程共享所在进程的资源,是 CPU 调度的基本单位。
Q:同一进程的线程共享什么、独占什么? **A:**共享:地址空间(代码段/数据段/堆/mmap)、全局/静态变量、fd 表、cwd、信号处理函数;独占:栈、寄存器、PC、TLS(含
errno)、信号屏蔽字、调度优先级。Q:两者之间怎么通信? **A:**进程间必须走 IPC(管道/共享内存/信号/socket),要经过内核;线程直接读写共享变量,代价小但必须自己加锁。
Q:创建和切换,哪个开销大? **A:**进程。创建:复制页表 + 建 PCB vs 建 task_struct + 栈;切换:换页表(写 CR3)、刷 TLB vs 不换页表、TLB 不失效。
Q:为什么线程切换比进程快? **A:**不换页表(CR3)、不刷 TLB,且共享同一地址空间,cache 局部性更好。
Q:一个线程崩了会怎样? **A:**共享地址空间,段错误/非法访问会让内核终止整个线程组,整个进程跟着死;进程之间地址空间隔离,互不连累。
易错:
- 「线程是轻量级进程」错误——Linux 里两者都是
task_struct,区别在共享程度,不是「重量」。 - 线程共享堆,所以一个线程
new的对象别的线程能直接拿到指针;也正因如此竞争高发。 - 共享 fd 表 → 线程 A
close(fd),线程 B 再用就失效。
关键字:
- cwd — current working directory,当前工作目录,进程的"相对路径基准"。open("a.txt") 的 a.txt 是相对 cwd 解析的。
- PC — program counter,程序计数器,CPU 下一条要执行的指令地址。每个线程都有自己的 PC 这是线程"独立执行流"的核心标志
- TLS — thread-local storage,线程局部存储。声明为 thread_local 的变量,每个线程各有一份,互不干扰。
- 典型用途就是 errno —— 如果 errno 是全局变量,多线程下 A 程的出错码会被 B 线程覆盖,所以它必须是线程独立的。
- TLB 页表高速缓存。CPU 里缓存"虚拟地址页 → 物理地址页"翻译结果的小表,避免每次访存都查页表。
- IPC — inter-process communication,进程间通信。进程地址空间隔离,不能直接读写对方变量,只能走内核或共享映射:
2. 进程有哪几种状态?(R/S/D/Z)
Q: 进程有哪些状态?线上怎么判断?
| 状态 | 含义 | 关键点 |
|---|---|---|
| R | 就绪/运行 | 时间片完 → 排队 |
| S | 可中断睡眠 | 等 I/O / sleep,能被信号唤醒 |
| D | 不可中断睡眠 | 直接 I/O,不响应信号,kill -9 也杀不掉 |
| T | 暂停 | SIGSTOP / SIGTSTP;SIGCONT 恢复 |
| Z | 僵尸 | 子进程退出、父进程未 wait |
追问:D 态为什么杀不掉?→ 内核在等不可中断的 I/O(如 NFS/磁盘),信号要等系统调用返回才处理。
易错:
- 僵尸态不是「子进程还在跑」,而是子进程已退出、PCB 未回收。
3. PCB / task_struct 里存了什么?
Q: PCB(进程控制块)是什么?里面有哪些内容?
一句话:PCB(进程控制块,Linux 里是 task_struct)是进程存在的唯一标识,创建进程就是建 PCB。
里面存:标识(PID/PPID)、现场(PC/寄存器/栈指针)、调度信息(状态/优先级/时间片)、资源(页表 mm_struct、fd 表 files_struct、信号)。
追问链:
- 一次进程切换的完整过程? 保存现场到 PCB → 更新状态入队 → 调度器选下一个 → 切换页表/地址空间 → 恢复现场 → 返回用户态。
易错:
- PCB 在内核空间,不是进程用户地址空间的一部分。
- 线程也有「PCB」,就是自己的
task_struct(TCB)—— 同进程下多线程共享
4. Linux 线程的本质是什么?tid 和 tgid 的区别?
一句话:Linux 没有「线程」,只有
task_struct;线程 = 带共享 flag 的clone。fork()≈clone(SIGCHLD)(几乎不共享);
pthread_create≈clone(CLONE_VM|CLONE_FILES|CLONE_FS|CLONE_SIGHAND|CLONE_THREAD, 新栈)。
tid vs tgid(必背)
| 名字 | 是什么 | 谁返回 |
|---|---|---|
| tid | 每个 task 的全局唯一号(内核里就叫 pid) | gettid() |
| tgid | 线程组 ID = 主线程 tid = 用户视角的进程号 | getpid() |
共享什么(背 5 个 flag)
| flag | 共享 |
|---|---|
CLONE_VM | 地址空间(页表) |
CLONE_FILES | fd 表 |
CLONE_FS | cwd |
CLONE_SIGHAND | 信号处理表 |
CLONE_THREAD | 同一线程组(tgid 相同) |
另:CLONE_CHILD_CLEARTID → 线程退出时清 tid 并用 futex 唤醒 pthread_join。
追问链
- 子线程里
getpid()返回什么?→ tgid(进程号),不是线程号。 pthread_join怎么知道线程退出?→CLONE_CHILD_CLEARTID+ futex。
易错
- 线程数看
/proc/PID/status的Threads:,ps默认只显示进程。
5. 上下文切换具体切换了什么?进程、线程、协程差多少?
Q: 上下文切换的开销在哪?为什么协程快?
| 切换类型 | 保存/恢复 | 是否进内核 | 是否换页表 | 量级 |
|---|---|---|---|---|
| 进程切换 | 寄存器、PC、SP、栈、内存映射 | 是 | 是 | 微秒级 |
| 线程切换 | 寄存器、PC、SP、栈 | 是(内核调度) | 否 | 比进程快 2~3 倍 |
| 协程切换 | 少量寄存器/栈指针 | 否 | 否 | 百纳秒级 |
隐藏开销:cache 污染、TLB 失效往往比保存寄存器本身更贵。
追问链:
- 系统调用算上下文切换吗?→ 不算,返回原线程。
- 为什么协程不能利用多核?→ 它是单线程内协作式调度;要「多线程 + 每线程多协程」才能吃满多核。
- 协程的代价?→ 一个协程阻塞会卡住整个线程;不能被抢占,长计算会饿死同线程其他协程。
易错:
- 「线程切换不进入内核」——错,Linux 线程切换由内核调度器完成,只是不换页表。
- 「协程一定比线程快」——单次切换快,但调度/栈管理/阻塞处理不当会更慢。
6. fork 为什么返回两次?写时复制是什么?
Q: fork 的返回值?COW 的原理和好处?
返回值:父进程得到子进程 PID(>0),子进程得到 0,失败返回 -1(只有父进程返回)。所以「调用一次、返回两次」。
COW(Copy-On-Write):
- fork 时不复制物理内存,只复制父进程的页表;
- 父子页表项指向同一批物理页,全部标为只读,物理页带引用计数;
- 任一方写 → 触发写保护缺页异常 → 内核
do_wp_page:- 引用计数 > 1:分配新页、拷贝内容、改页表、恢复可写;
- 引用计数 == 1:没人共享,直接恢复可写(零拷贝优化)。
好处:fork 的开销从「复制整个地址空间」降到**「复制页表 + 创建 task_struct」**
追问链:
- fork 后父子谁先跑?→ 不保证,由调度器决定。
vfork和 fork 区别?→ vfork 共享地址空间且阻塞父进程直到子 exec/exit,已被 COW 取代。
易错:
- fork 复制的是页表,不是物理页。
- COW 只复制被写的那一页,不是整个地址空间。
7. exec 和 wait 做了什么?
Q: exec 会创建新进程吗?wait/waitpid 怎么用?
exec 族:不创建新进程,用新程序替换当前进程映像——换内容、留外壳。
| 保留 | 替换 |
|---|---|
| PID/PPID、fd(默认)、cwd | 代码/数据/堆/栈、信号处理函数→默认、环境变量 |
命名:exec[l|v][p][e]——l 逐个参数 / v 数组;p 搜 $PATH;e 自定义环境变量。系统调用只有 execve,其余是 glibc 包装。
wait / waitpid:
wait(&st)等任一子进程;waitpid(pid, &st, opt):pid > 0指定;-1任一;0同组;<-1指定组;
追问链:
- exec 后 fd 还在吗?→ 默认保留,这正是 shell 重定向的原理(exec 前
dup2到 0/1/2) - exec 后信号处理函数还在吗?→ 捕获的处理函数重置为默认;忽略的保持忽略。
system()是什么?→ fork + exec + wait 的封装。
易错:
- exec 成功不返回,失败返回 -1。
exit()是库函数(会刷新 stdio 缓冲、跑 atexit),_exit()是系统调用;fork 的子进程应用_exit,否则可能重复刷新父进程缓冲。
8. 僵尸进程和孤儿进程是什么?怎么处理?
Q: 僵尸进程怎么产生?有什么危害?怎么清理?
僵尸进程:子进程先退出,父进程还活着但没 wait 回收。子进程的代码/数据/堆/栈/fd 都已释放,只残留 task_struct(几 KB 内核内存),状态 Z。
- 危害:占 PID/PCB 表项,大量僵尸会耗尽 PID,无法创建新进程。
- 清理:
- 父进程及时
wait/waitpid; SIGCHLDhandler 里循环while (waitpid(-1, NULL, WNOHANG) > 0);——信号不排队,多个子进程同退可能只触发一次;signal(SIGCHLD, SIG_IGN)让内核自动回收(Linux);- 杀掉父进程,僵尸变孤儿被 init 收养;
- fork 两次:子进程立刻退出被父进程回收,孙进程成孤儿归 init。
- 父进程及时
孤儿进程:父进程先退出,子进程还在运行,被 init(PID 1)收养,退出时由收养者回收,无害。
追问链:
- 僵尸占内存吗?→ 只占
task_struct和 PID,不占用户内存/CPU/fd。 - 为什么 SIGCHLD handler 要 while?→ 标准信号不排队,可能多个子进程退出只合并成一个信号。
- 容器里 PID 1 不收尸会怎样?→ 僵尸堆积,容器内 PID 耗尽
易错:
- 僵尸不是「还在运行」,不能靠 kill 解决。
9. 进程的虚拟地址空间怎么布局?
Q: 从低地址到高地址,进程地址空间有哪些段?
text
低地址
0x0 附近:保留区(NULL 解引用 → SIGSEGV)
.text 代码段 r-x
.rodata 只读常量 r--
.data 已初始化全局/静态 rw-
.bss 未初始化/为 0 的全局/静态 rw-
heap 堆(↑ brk/sbrk,malloc 小块)
mmap 区 共享库、大块 malloc、文件映射(↓)
stack 栈(↓,默认 8MB)
内核空间
高地址1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
追问链:
.data和.bss区别?.data和.bss都是放全局变量/静态变量的可写数据区,运行时都占内存。- 核心区别是:变量的初值要不要在 ELF 文件里显式存下来。
- **
.data:已初始化、且初值通常非 0 的全局/静态变量。**初值必须写进文件,所以它占文件体积 .bss:未初始化,或初值全为 0 的全局/静态变量。它不占文件体积
- **
堆和栈谁快?→ 栈快:只移动栈指针,无锁无系统调用,内存连续、cache 友好。
字符串只读常量在哪?→
.rodata(只读常量区);char a[] = "abc"整个数组在栈上。
易错:
- 内存泄漏只发生在堆(以及未释放的 mmap/资源),栈自动回收。
10. 多进程和多线程怎么选?线程数开多少?
Q: 高并发服务器用多进程还是多线程?线程池开多少线程?
| 多进程 | 多线程 | |
|---|---|---|
| 隔离性 | 好,一个崩不影响其他 | 差,一个线程崩全进程死 |
| 通信 | IPC,麻烦 | 共享内存,快但要加锁 |
| 开销 | 创建/切换贵、内存占用大 | 创建/切换便宜 |
| 利用多核 | 好 | 好 |
| 适用 | 稳定/隔离优先(nginx、Chrome) | 共享状态多、低延迟(muduo) |
工程常用组合:多进程 + 每进程多线程/协程——进程吃隔离和多核,线程/协程吃并发连接。
线程数:
- CPU 密集型:
N ≈ 核数(或核数 + 1); - I/O 密集型:
N = 核数 × (1 + 平均等待时间 / 平均计算时间); - 理论值只是起点,最终靠压测找 QPS/延迟拐点;线程数超过核数后收益递减,切换和 cache 失效反而拖慢。
线程池为什么快:
- 复用线程,省掉创建/销毁(分配 ~8MB 栈 +
clone系统调用); - 任务到达即刻执行,降低响应延迟;
- 固定上限,天然限流、便于监控。
追问链:
- 线程池核心组件?→ 任务队列 + mutex + condition_variable + 工作线程循环 + stop 标志。
- 任务队列满了怎么办?→ 阻塞提交 / 丢弃 / 抛异常 / 调用者执行(拒绝策略)。
- 为什么执行任务时不能持锁?→ 否则所有 worker 串行,线程池退化。
易错:
- 「线程越多并发越高」——错,超过核数后主要是切换开销。
- 进程池不是「进程越多越好」,还受内存、fd、PID 限制。
11. 协程是什么?有栈和无栈有什么区别?
协程是一种用户态、可挂起和恢复的轻量级执行单元。它不像线程那样由操作系统内核调度,而是由程序里的运行时/调度器在用户态切换。一个线程上可以跑很多协程。
协程主要不是为了“让出 CPU”,而是:在等待 IO 等事件时,挂起当前协程,让同一个线程继续执行其他协程,避免整个线程被阻塞。
它解决的是:大量并发 IO 任务下,线程成本高、阻塞等待浪费线程的问题。
| 事件 | 线程 + 阻塞 IO | 协程 + 非阻塞 IO |
|---|---|---|
| 等待时谁被挂起 | 整个线程 | 当前协程 |
| 线程能不能干别的 | 不能 | 能,继续跑其他协程 |
| 并发单位成本 | 高,一个连接一个线程 | 低,一个连接一个协程 |
| 切换成本 | 内核态,较贵 | 用户态,较轻 |
| 调度方式 | 抢占式,内核调度 | 通常协作式,协程主动让出 |
Q: 协程和线程的区别?为什么切换快?C++20 协程是什么?
一句话:协程是用户态轻量级执行流,由用户程序/运行时调度,内核不可见,协作式(非抢占),只在 co_await/yield/I/O 阻塞时主动让出。
快的原因:
- 切换在用户态完成,无用户态/内核态切换;
- 不换页表、不刷 TLB;
- 只保存少量寄存器(百纳秒级);
- 单线程内协程串行执行,共享变量可不加锁。
代价:
- 一个协程阻塞会卡住整个线程;
- 单线程协程无法利用多核,必须「多线程 + 每线程多协程」;
- 不能被抢占,长计算会饿死同线程其他协程。
| 有栈协程(libco/Boost.Coroutine) | 无栈协程(C++20/Rust/JS) | |
|---|---|---|
| 独立栈 | 有,每协程几 KB~MB | 无,编译器生成状态机 |
| 挂起位置 | 任意嵌套函数 | 只能在协程函数顶层 co_await |
| 切换开销 | 较高(保存整个栈,微秒级) | 极低(纳秒级) |
| 风险 | 栈大浪费、栈小爆栈 | 省内存、无爆栈,但灵活性差 |
C++20 协程:函数体含 co_await/co_yield/co_return 即为协程;返回类型需要 promise_type;局部状态分配在堆上。坑:停在 final_suspend 需手动 coro.destroy();co_await 前后可能在不同线程。
追问链:
- 协程能替代线程池吗?→ 不能,协程解决「等待时让出」,CPU 密集仍需线程并行。
- 协程和回调/Future 比好在哪?→ 用同步写法表达异步逻辑,避免回调地狱。
易错:
- 协程不是并行执行,单线程内仍是串行。
- 协程切换快 ≠ 协程没有开销(状态机、堆分配、调度器)。
三、CPU 调度
1. 调度时机
调度时机:运行 → 阻塞(等 I/O、锁);运行 → 就绪(时间片到、被抢占);阻塞 → 就绪(事件完成,可能触发抢占);进程退出;新进程创建/唤醒(可能抢占)。非抢占式只在阻塞/退出时让出。
2. Linux 的 CFS 调度器怎么工作?(高频)
Q: 讲一下 CFS 的原理。为什么要用红黑树?
在理想情况下,所有可运行任务的 vruntime 在任何时刻都应该完全相等。因此,真实 CPU 上的 CFS 只需要做一件事:总是选择 vruntime 最小的任务来运行,因为它就是“在理想世界里被亏欠最多”的那个。
如果所有任务 k 相同,那么实际跑多久,vruntime 就涨多少,这很公平。但现实是任务有轻重缓急,所以每个任务有一个倍率 k:同样跑 1ms,k 大的任务账涨得更快,更早被换下。
核心公式:
vruntime_new = vruntime_old + 实际运行时间 × k
- k:倍率(虚拟时间倍率),由 nice 决定。nice 0 → k = 1;nice 越高 k 越大。
- vruntime_old:本次运行前该任务累计的虚拟运行时间。
- nice 不是优先级,只是调 k 的旋钮:k 大 → 涨得快 → 很快轮到别的进程。
内核写法是
k = NICE_0_LOAD / 权重(NICE_0_LOAD = 1024),权重由 nice 查表得到。理解时只需记住「nice 调 k」
红黑树:每个 CPU 一个运行队列,可运行任务按 vruntime 挂在红黑树上;最左节点就是下一个要跑的。
为什么用红黑树不用堆:CFS 需要频繁删除任意任务(阻塞、迁移),堆删除任意节点要额外维护下标;红黑树天然 O(log n) 增删查。
追问链:
- 新 fork 的进程 vruntime 从 0 开始吗?→ 不行,会独霸 CPU;初始化为父进程 vruntime 附近。
- 为什么 CFS 天然照顾 I/O 密集任务?→ I/O 任务累计 CPU 少,vruntime 低,醒来容易被优先调度。
易错:
- CFS 不是「每个任务绝对等分」,而是 k 越小分得越多;
- vruntime 不是真实 CPU 时间,而是按 nice 0 折算出的虚拟时间。
3. 优先级反转是什么?怎么解决?
优先级反转:低优先级任务持锁 → 中优先级抢占它 → 高优先级等锁被间接拖住。
解决:优先级天花板(持锁时提升到所有使用者的最高优先级)
易错:优先级反转不是死锁,是「高优先级被中优先级间接拖延」。
4. 多核调度要考虑什么?
- 每 CPU 一个运行队列,避免全局锁竞争;周期性的把忙核中的任务迁移到闲核。
- CPU 亲和性:让任务尽量留在同一核,保住 cache/TLB 。
- 唤醒亲和:任务醒来优先放回原核或共享 cache 的核。
追问:为什么不要频繁迁移?→ cache/TLB 失效 + 迁移本身有开销。适当迁移的好处?→ 避免负载不均时浪费核。
易错:多核不等于线性加速,受 Amdahl 定律、锁竞争、内存带宽限制。
四、同步与互斥
1. 什么是竞态条件?临界区怎么保护?
Q: 竞态条件是怎么产生的?临界区是什么?
竞态条件(Race Condition):多个执行流并发访问共享数据,最终结果依赖执行时序。
临界区:访问共享资源的那段代码,必须互斥执行。
追问链:
- 单条
counter++是原子的吗?→ 不是,编译成 load/add/store 三条指令,中间可被抢占。 - 加锁一定安全吗?→ 还要保证锁保护的是同一份数据、所有访问路径都加锁、锁粒度正确。
易错:
- 只读共享数据不加锁通常安全,但「读的同时有写」就不安全。
std::atomic保证单变量原子性。
2. 互斥锁和自旋锁有什么区别?怎么选?
Q: 互斥锁和自旋锁的适用场景?
核心区别:拿不到锁怎么办。
| 互斥锁 | 自旋锁 | |
|---|---|---|
| 等待方式 | 睡眠让出 CPU,锁释放后由内核唤醒 | 用户态循环 CAS 忙等,不让 CPU |
| 开销 | 两次上下文切换(睡+醒),微秒级 | 无切换,纳秒级;但占用 CPU |
| 实现 | futex(无竞争走用户态CAS,有竞争进内核) | CAS |
| 适合 | 临界区长、竞争激烈 | 临界区极短,多核CPU |
选型口诀:短、多核、不睡 → 自旋;其余一律 mutex。
追问链:
- 单核上自旋锁为什么危险?→ 持锁者被换下(还未执行完,无法释放锁),自旋者不让 CPU,可能永远等不到锁。
- glibc 的 mutex 是纯睡眠吗?→ 不是,先自适应CAS自旋一小段,再 futex 睡。
易错:
- 「自旋锁一定比互斥锁快」——只在临界区极短且低竞争时成立。
3. futex 是什么?为什么它是 Linux 锁的基石?
Q: 讲一下 futex 的原理。
一句话:futex 让无竞争时加解锁完全在用户态完成,只有真正需要睡眠时才进内核。
内核只提供两个操作:
| 操作 | 语义 |
|---|---|
FUTEX_WAIT(addr, status) | 若 *addr == status 则挂起睡眠;否则立即返回 EAGAIN |
FUTEX_WAKE(addr, n) | 唤醒至多 n 个等在 addr 上的线程 |
两级路径:
text
加锁:
① 用户态 lock cmpxchg:成功 → 拿到了,全程没进内核(fast path)✅
② 失败 → 阻塞前 FutexWait(futexword, 期望值),内核确认后挂起(slow path)
解锁:
FutexWake 唤醒一个等的人(没人等/无竞争时这一步也可以省掉)1
2
3
4
5
2
3
4
5
为什么高效:无竞争时 0 次系统调用;有竞争时在内核里挂起/唤醒。
追问链:
FUTEX_WAIT为什么要传「期望值」?→ 防止「检查后发现要睡,但睡之前锁已被释放」的丢失唤醒窗口。- 条件变量和 futex 什么关系?→ glibc 的条件变量底层用 futex 实现睡眠/唤醒。
- 怎么观察竞争程度?→
strace -f -c -e trace=futex,futex 次数越多说明真实竞争越激烈。
易错:
- futex 不是「一把锁」,是内核提供的等待/唤醒原语,锁逻辑仍在用户态。
4. 读写锁是什么?有什么坑?
Q: 读写锁的语义?适合什么场景?
- 读读并行:多个读者可同时持有读锁;
- 读写互斥:读者和写者不能同时;
- 写写互斥:写者独占。
适合读多写少。不适合写多、或临界区极短的场景(读写锁本身有开销)。
坑:
- 写者饥饿:读者源源不断,写者一直等;
- 锁升级死锁:持有读锁再申请写锁,若两个线程同时想升级,会互等对方的读锁释放;
- 实现开销:维护读者计数、写者等待队列,比普通 mutex 重。
追问链:
- 读写锁能升级吗?→ C++
std::shared_mutex不能原地升级,必须先释放读锁再申请写锁(中间可能被插队)。 - 读多写少还有别的方案吗?→ RCU、COW、
shared_ptr原子读、分段锁。
易错:
- 读写锁不是「读一定不阻塞」:有写者等待时,新读者可能被阻塞(写优先实现)。
5. 条件变量为什么必须配 mutex?wait 为什么必须放 while?
Q:
condition_variable的用法和原理?
配 mutex 的原因:
- 判断条件本身要读共享变量,必须受锁保护;
wait内部要原子地「释放锁 + 挂起」,否则会出现「判断完但还没睡,通知就来了」的丢失唤醒。
用 unique_lock 而非 lock_guard:wait 内部需要反复 unlock/lock,lock_guard 不支持中途解锁。
必须 while 而不是 if:
- 虚假唤醒:、会出现没有 notify 也返回;
notify_all唤醒多个线程后,先抢到锁的把条件消耗掉了,后来的线程醒来条件已不成立。
cpp
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, [&]{ return !queue.empty() || stop; }); // 内部就是 while1
2
2
notify_one vs notify_all:
notify_one只唤醒一个等待者,O(1);notify_all广播唤醒全部,醒来抢同一把锁,通常只有一个能干活,其余白醒再睡 → 惊群。- 能
notify_one就别notify_all;notify_all只用于全局状态变化(shutdown)。 - notify 前不必持锁;持锁通知会让被唤醒线程立刻又阻塞。
追问链:
- 条件变量会「记住」通知吗?→ 不会,没有等待者时 signal 直接丢失;信号量会记住。
- 为什么
wait返回后要重新检查条件?→ 可能虚假唤醒、也可能条件被别的线程改掉。 - 条件变量能替代信号量吗?→ 简单计数可以用条件变量 + 计数器模拟,但信号量有计数语义、可跨线程 post。
易错:
- 虚假唤醒(没通知也醒)和惊群(唤醒太多)是两回事,但都要求 while 重检。
notify_one不保证唤醒「正确的那个」等待者;多个条件共用一个 cv 时要小心。
6. 信号量、条件变量、互斥锁有什么区别?
Q: 三者的语义和选型?
| 互斥锁 | 信号量 | 条件变量 | |
|---|---|---|---|
| 语义 | 0/1 互斥 | 计数器(N 个资源) | 等待/通知,不计数 |
| 谁释放 | 谁加锁谁解锁 | 不要求同一线程(可跨线程 post) | 配合 mutex 使用 |
| 通知是否丢失 | — | post 会被记住 | 没有等待者时 signal 丢失 |
| 能否广播 | — | 可唤醒多个 | 支持 notify_all |
| 典型 | 保护临界区 | 限流、资源计数 | 生产者消费者等复杂条件 |
选型:
- 条件是「整数资源数 > 0」→ 信号量;
- 条件复杂、需要广播 → mutex + 条件变量;
- 只保护临界区 → 互斥锁。
追问链:
- 条件变量为什么不能单独用?→ 没有锁保护条件变量本身,也没有「释放锁 + 睡眠」的原子性。
易错:
- 信号量不传数据,只做同步/计数。
- 互斥锁保护的是「代码段」,信号量保护的是「资源数量」。
7. 什么是 CAS?ABA 问题怎么解决?
Q: CAS 的原理和缺陷?
CAS = Compare-And-Swap:比较内存值 V 与预期值 A,相等才写入 B,整条指令硬件原子。
三个问题:
- ABA:值 A→B→A,CAS 察觉不到中间变化。CAS 误判成功,导致结构损坏。
- 解决:带版本号的指针(指针 + 计数器打包);
- 自旋开销:高竞争下反复失败空转 CPU。
- 只能保证单个变量的原子性,多变量无能为力。
追问链:
- CAS 和锁比什么时候更优?→ 低竞争、临界区极短、不能睡眠的场景;高竞争时互斥锁更稳。
- 无锁一定更快吗?→ 不是,CAS 空转、伪共享、内存回收都可能让它更慢。
易错:
- ABA 不是「值变了又变回来」这么简单,危害在对象生命周期/节点复用。
8. 内存序有哪些?怎么选?
Q: C++ 的内存序有哪些?release/acquire 怎么配对?
| 内存序 | 保证 | 典型用途 |
|---|---|---|
relaxed | 只有原子性,不保证顺序 | 纯计数器 |
acquire(配 load) | 本线程后续读写不许提前到这条之前 | 读「发布标志」 |
release(配 store) | 本线程此前读写不许拖后到这条之后 | 发布数据 |
acq_rel | 兼具两者(读-改-写操作用) | CAS、fetch_add |
seq_cst | 全局单一总序(默认,最强最贵) | 拿不准时、多原子变量协同 |
发布-订阅配对:
cpp
// 线程 1(发布) // 线程 2(订阅)
data = 42; while (!flag.load(acquire));
flag.store(1, release); 用 data; // 保证读到 421
2
3
2
3
release用在 store:前面的写不能跑到这个 store 后面;acquire用在 load:后面的读写不能跑到这个 load 前面。
选序口诀:只保护自己 → relaxed;发布/订阅一对变量 → release + acquire;多个原子量之间也要顺序 → seq_cst。
追问链:
- 为什么需要内存序?→ 编译器和 CPU 都会重排;多核下其他线程看到的写顺序可能不同。
volatile能替代atomic吗?→ 不能,volatile不保证原子性、不阻止 CPU 重排。
易错:
relaxed不是「不原子」,它仍然原子,只是不保证跨变量的顺序。
9. 无锁队列怎么实现?什么时候不该用无锁?
Q: SPSC 无锁环形队列的原理?
**SPSC(单生产者单消费者)**最实用:日志线程、音视频管道、muduo 异步日志。
cpp
template <typename T, size_t N>
class RingQueue { // N 为 2 的幂可省去取模
T buf[N];
std::atomic<size_t> w{0}, r{0}; // 只有生产者写 w,只有消费者写 r
bool push(const T& v) {
size_t ww = w.load(std::memory_order_relaxed);
if (ww - r.load(std::memory_order_acquire) == N) return false; // 满
buf[ww % N] = v; // ① 先填数据
w.store(ww + 1, std::memory_order_release); // ② 再发布下标
return true;
}
bool pop(T& v) {
size_t rr = r.load(std::memory_order_relaxed);
if (rr == w.load(std::memory_order_acquire)) return false; // 空
v = buf[rr % N];
r.store(rr + 1, std::memory_order_release);
return true;
}
};1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
为什么简单:w 只有生产者写、r 只有消费者写 → 没有 CAS 竞争;唯一要小心的是「数据先写、下标后发布」,靠 release/acquire 配对保证。
- 需要维护多个字段的不变量的时候不该用无锁;
- 先加锁写对 → 压测确认锁是瓶颈 → 只把最热的点换成无锁。
- 低竞争、任务耗时长时,有锁队列更好(阻塞不烧 CPU)。
追问链:
- 环形队列为什么要 2 的幂?→
% N可优化成& (N-1)。 - 无锁队列满了怎么办?→ 返回 false、自旋、或覆盖最旧数据(取决于业务)。
易错:
- SPSC 不需要 CAS
10. 锁的优化手段有哪些?
Q: 高并发下锁竞争严重,怎么优化?
- 缩小临界区:只保护共享数据;
- 降低锁粒度 / 线程本地化:分段锁、per-thread 计数最后汇总;
- 读写分离 / 无锁:读多写少用读写锁;计数用原子操作、单生产单消费用 SPSC 队列;
追问链:
- 分段锁怎么选段数?→ 通常 2 的幂,按 hash 映射;段数太多浪费内存,太少竞争高。
易错:
- 锁粒度不是越小越好:锁太多会增加开销和死锁风险。
五、死锁
1. 死锁的定义和四个必要条件?
Q: 什么是死锁?四个必要条件是什么?
死锁:一组进程/线程互相等待对方持有的资源,形成循环等待,无外力永远无法推进。
四个必要条件(同时满足才可能死锁,破坏任一即可):
| 条件 | 含义 | 怎么破坏 |
|---|---|---|
| 互斥 | 资源一次只能被一个持有 | 资源共享/无锁结构 |
| 请求与保持 | 持有资源的同时申请新资源 | 一次性申请全部资源 |
| 不可剥夺 | 资源不能被强行夺走 | 允许抢占/超时释放 |
| 循环等待 | 存在进程-资源的环 | 统一加锁顺序 |
追问链:
- 四个条件都满足一定死锁吗?→ 不一定。单实例资源有环即死锁;多实例资源有环只是可能,需要化判定。
- 死锁和活锁、饥饿的区别?→ 死锁全员阻塞;活锁都在跑但白跑;饥饿是个别线程长期拿不到资源。
易错:
- 四条件是必要条件,不是充分条件。
- 「循环等待」是工程上最容易破坏的(统一锁序)。
2. 工程上怎么防死锁?
死锁是四个条件同时满足才可能发生的,所以工程上就是逐条破坏:少共享 → 定顺序 → 一次拿 / 拿不到就退,用超时日志兜底。
一、设计上:能不共享就不共享(破「互斥」)
- 用
std::atomic、thread_local、分段锁、无锁队列; - 一句话:没有共享就没有锁,没有锁就不会死锁。
二、加锁上:三条铁律
定顺序:所有线程按同一个顺序加锁(如按地址/ID 升序)——破「循环等待」,最有效;
一次拿:多把锁用
std::scoped_lock一次性申请,别先拿 A 再拿 B;- cpp
std::lock_guard<std::mutex> lock1(from.m); // 先锁 from std::lock_guard<std::mutex> lock2(to.m); // 再锁 to // 一次性申请两把锁,内部避免死锁 // C++17 std::scoped_lock lock(from.m, to.m); // // C++11 std::unique_lock<std::mutex> lock1(from.m, std::defer_lock); std::unique_lock<std::mutex> lock2(to.m, std::defer_lock); std::lock(lock1, lock2);1
2
3
4
5
6
7
8
9
10
11
12
拿不到就退:
try_lock_for设超时,失败就释放已持有的锁再重试——破「请求与保持」。
三、代码纪律:持锁时间要短,且必须保证解锁
- 缩小临界区:持锁不调用外部回调、不做 I/O、不嵌套加锁;
- RAII:
lock_guard/unique_lock,异常路径也能自动解锁; - 不锁升级:读锁里不要再申请写锁。
四、兜底:加锁带超时 + 日志记录「谁在持锁」,线上出问题能直接定位。
3. 线上死锁怎么排查?
Q: 进程卡死了,怎么判断是不是死锁?
pstack <pid>连打两三次,或gdb -p <pid>后thread apply all bt;- 找栈一直不变且停在
pthread_mutex_lock/__lll_lock_wait/futex的线程; - 若线程 A 持锁 X 等 Y、线程 B 持锁 Y 等 X → 判定死锁,回代码找加锁顺序不一致;
- 兜底:加锁超时 + 日志打印「谁在持锁」,比事后查栈快。
追问链:
- 死锁和线程池耗尽怎么区分?→ 死锁的线程栈停在锁上且不变;线程池耗尽通常栈停在任务等待/条件变量。
六、内存管理
1. 什么是虚拟内存?为什么需要它?
Q: 虚拟内存的作用?
虚拟内存是 OS 给每个进程的私有、连续、独立的地址空间抽象:进程只看到虚拟地址,由 MMU + 页表翻译成物理地址。
三个作用:
- 隔离与保护:进程间互不可见,PTE 带 R/W/X 权限,越权访问直接段错误;
- 容量扩展:按需分页 + swap,可用空间可超过物理内存;
- 简化管理:
malloc只需拿一段连续虚拟地址,物理页框可以离散;
2. 虚拟地址怎么翻译成物理地址?为什么要多级页表?
Q: 虚拟地址怎么翻译成物理地址?
地址 → 逐级查表 → 拼物理地址。
- 拆:x86-64 实际只有 48 位有效虚拟地址(高 16 位符号扩展),按 4KB 页拆成 36 位虚拟页号 VPN + 12 位页内偏移;
- 查:MMU 从
CR3拿到页表基址,用 VPN 逐级查页表,最后一级表项里存的就是物理页号 PFN; - 拼:
物理地址 = PFN << 12 | offset。
(VPN = virtual page number,PFN = Page Frame Number)
为什么要多级页表?
每个进程的地址空间独立,就意味着每个进程都要有自己的一整套页表。假如只用一级页表:
- VPN 有 36 位 → 页表需要 2^36 项,每项 8B ≈ 512GB,而且必须连续存放在数组中,方便查询;
- 但进程真正用到的地址通常只有几 MB ~ 几 GB,绝大部分页号根本没有映射,这 512GB 里绝大多数项永远是
nullptr。
多级页表把 36 位 VPN 切成 4 段 9 位(9+9+9+9=36),每级表正好 2^9 = 512 项 × 8B = 4KB = 一页:
- 查表像走 4 层树:第 1 级表项指出第 2 级表的物理地址,逐层缩小范围;
- 顶级页表常驻,下级表用到才分配——某段地址从来没访问过,对应的下级表就根本不存在,表项置空即可;
- 效果:把「覆盖整个地址空间的大数组」变成「按实际用量生长的树」,只为用到的地址分配内存。
代价:一次翻译最多有 4 次访存,加上取数据共 5 次,所以必须靠 TLB 把常用页表项缓存起来。
TLB:CPU 内的页表项缓存,命中直接出物理地址;未命中才走页表遍历。靠TLB,命中率 98%+。
页表项(PTE):物理页号、存在位 P、修改位 M(脏位)、访问位 A、权限位(R/W/X)、用户/内核位。
易错:
- TLB 它缓存的是页表项,不是具体的页。
- 多级页表省的是「未使用区域的页表」。
- 单级页表浪费的根源是地址空间稀疏(大部分页号无映射),不是页表项本身太大。
3. 缺页中断的完整流程?
Q: 访问一个不在物理内存的页,过程是什么?
- CPU 访问一个虚拟地址;TLB 未命中,MMU 去查页表(PTE 有效则装入 TLB 直接返回);
- 发现 PTE 无效或权限不符(未分配 / 已换出 / COW / 越权访问)→ 触发缺页异常,陷入内核;
- 内核确认地址合法,非法 → SIGSEGV;
- 有空闲页框就分配;没有就选牺牲页——脏页先写回磁盘;更新牺牲页的 PTE 并清掉它的 TLB 项;
- 牺牲页就是缺页时被页面置换算法选中、从物理内存中换出以腾出页帧的那个页
- 读入所需页,更新 PTE(P=1、填 PFN)并写入 TLB;
- 重新执行被中断的那条指令(不是下一条)。
追问链:
- 缺页和普通中断的区别?→ 缺页是同步异常,处理完重执行原指令;
- 缺页一定是坏事吗?→ 不是,按需分页 / COW / mmap 都靠它实现;首次访问大数组慢就是因为每页缺一次;
- 缺页处理可能主动让出 CPU,进入阻塞状态,所以不能在原子上下文/自旋锁里触发。
易错:
- 缺页 ≠ 从磁盘读页:缺页是 MMU 查 PTE 时发现“该虚拟页当前不能直接访问”而触发的异常;“从磁盘读页”只是处理缺页的一种方式。像 COW 写时复制触发的缺页,原页通常已在内存中,内核只需分配一个新物理页并把内容复制过去,一般不需要磁盘 I/O。
- 进程切换不必然缺页,只有访问的页没有有效映射才缺。
4. malloc 底层怎么实现?brk 和 mmap 怎么选?
Q:
malloc是怎么拿到内存的?为什么大块走 mmap?
malloc 是库函数(glibc ),不是系统调用;它先管自己的“空闲内存池”,不够才找内核。
不管 brk 还是 mmap,拿到的都只是虚拟内存;当第一次读写才触发缺页,分配物理页。
找内核要内存时:小块用 brk 扩堆,大块用 mmap 单独映射;
申请 malloc(size) 时,glibc 的 ptmalloc 大致按这个顺序:
malloc(size)
↓
先看缓存:tcache → fastbin → smallbin → unsorted → largebin
↓ 有合适空闲块
直接复用,返回
↓ 没有
向内核要内存:
小块 → brk/sbrk 扩堆
大块 → mmap 匿名映射1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
- tcache:线程私有,无锁,最快,小块先走它。
- fastbin:小块,LIFO,不合并,省开销但容易碎片。
- smallbin / largebin:更大的块,按大小组织。
- unsorted bin:中转站,放不进前面的块先丢这里,等后续整理。
Q: 为什么大块走 mmap?
brk是移动进程的堆顶指针,堆是一整块连续区域。如果低地址的块没释放,高地址即使空闲,堆顶也收不回来。free 后小块通常不还给 OS,而是放进 bins 复用。只有堆顶空闲超过阈值,才可能收缩归还。
大块用 mmap 匿名映射,相当于单独租一块区域。free 时可以直接 munmap 还给系统
5. mmap 的四种组合?共享内存怎么实现?
Q:
mmap的 MAP_SHARED/MAP_PRIVATE 和文件映射/匿名映射组合?
mmap 由两个维度组合:
- SHARED + 文件:多进程映射同一文件时共享同一份 Page Cache,写会改页缓存、由内核回写;
- SHARED + 匿名:fork 后父子共享同一块内存;
- PRIVATE + 文件:读共享,写时复制,触发 COW,拷贝到私有副本、不影响其他进程;
- PRIVATE + 匿名:私有匿名内存,malloc 大块走的就是它。
文件/匿名决定背后有没有文件;SHARED/PRIVATE 决定写后别人看不看得见、回不回文件。
追问链:
- mmap 读文件算零拷贝吗?→ 只省掉「内核 Page Cache → 用户缓冲」的一次 CPU 拷贝,磁盘 → Page Cache 的 DMA 免不了;
- mmap 写文件什么时候落盘?→
mmap写文件默认不会立即落盘,它的落盘时机由内核的异步回写策略决定,也可以主动强制同步
易错:
mmap调用只建映射、不读盘,首次访问才缺页,然后读盘写内存
6. 内存碎片、伙伴系统、Slab 是什么?
Q: 内部碎片和外部碎片?伙伴系统和 Slab 各解决什么?
- 外部碎片:空闲内存总量够但不连续,凑不出一块大的;
- 内部碎片:分配出去但用不上的部分(页对齐/取整造成)。
对策:伙伴系统治外部碎片,Slab 治内部碎片。
伙伴系统:按 2 的幂(1~1024 页)管理空闲块,不够就二分拆,释放时与「伙伴」逐级合并;但只能按 2 的幂分配,仍有内部碎片。
Slab:内核小对象(task_struct 等)不直接走伙伴系统,而是从特定内存池里取,用完放回,下次复用。 减少反复分配/初始化。
追问链:
- Slab 和内存池区别?→ 思想相同(预分配 + 复用),但 Slab 在内核、按对象类型;用户态内存池按大小分级;
易错:
- 伙伴系统只能按 2 的幂分配,不是「任意大小」,仍有内部碎片;
- Slab 解决的是内核小对象的分配效率/碎片,不是用户态
malloc。
7. 内存池、tcmalloc、jemalloc 怎么选?
Q: 为什么高并发服务要换掉 glibc malloc?
痛点:malloc 太通用,多线程下锁竞争是瓶颈,频繁分配释放还增加碎片和系统调用。
- 内存池:定长用大块 + 空闲链表 O(1);变长按 8/16/32… 或 2 的幂分级;
- tcmalloc 三层:ThreadCache(每线程无锁)→ CentralCache(桶锁,批量补货)→ PageCache(按页管理 Span,合并相邻空闲页);
- 选型:
- 海量小对象、RPC → tcmalloc;
- 长期运行、大小多样(数据库/Web)→ jemalloc。
易错:先确认 malloc 是瓶颈再换;内存池不一定更快(小池/低并发可能不如系统 malloc),tcmalloc/jemalloc 也有碎片和内存膨胀。
8. VSZ、RSS、PSS 有什么区别?OOM 怎么发生?
Q:
top里的 VIRT/RES/SHR 是什么?内存不够时会发生什么?
- VSZ(VIRT):虚拟地址空间,包含还没分配物理页的映射——大不代表真占内存;
- RSS(RES):常驻物理页,但共享库/共享内存会重复计数;
- PSS:按共享比例分摊后的 RSS,多进程/容器场景更准。
OOM:内存不足时先把不常用的匿名页换出到 swap(频繁换入换出 = 抖动);仍不够就按 oom_score 选进程杀掉
易错 / 追问:
- VSZ 大不代表占内存多;RSS 涨不一定是泄漏(可能是缓存/内存池/大页),要看是否单调不回落;
free小但available大是正常的,因为大量内存被 Page Cache 占着, Page Cache 是可回收的。free是"现在完全空闲的内存",available是"新程序还能申请到的内存- Linux 的设计哲学就是:空闲内存不用白不用,拿去做缓存;真需要时再收回来。
9. 静态大页和透明大页(THP)是什么?
Q: 大页为什么能提升性能?
大页和透明大页解决的问题:如何降低 CPU 地址转换的开销。(虚拟地址转为物理地址)
核心思路:把默认的 4KB 小页换成更大的页(比如 2MB 或 1GB),从而减少页表项数量、减轻 TLB 压力。
Q: 静态大页和透明大页区别?
- 静态大页:手动预留,确定性强,预留的大页不参与 Swap,也不会被内核回收,永远常驻物理内存。
- 预留过多会挤压普通内存,且配置不够灵活。
- 透明大页(THP):内核会动态地尝试把相邻的 4KB 小页合并成 2MB 大页,对应用完全“透明”。
- 会造成内存膨胀,只需少量数据也可能占住 2MB 大页
- 后台开销:内核线程持续扫描合并页面,会抢内存锁,与应用争抢,带来性能抖动。
10. 内存泄漏怎么排查?
Q: 线上内存持续上涨,怎么定位?
- 确认是不是泄漏:看进程 RSS 是否单调上涨不回落;
free小但available大是 Page Cache,不算; - 定位区域:
top/ps找到进程,pmap -x、/proc/PID/smaps_rollup看是[heap]、mmap 区还是文件缓存; - 抓现场:测试环境用 valgrind / ASan(越界、UAF 也能查);生产用 tcmalloc/jemalloc heap profiler,两个时间点快照做 diff;
- 先止血:
dmesg | grep -i oom确认 OOM,容器看 cgroup;先限流/扩容/热重启,再回头修代码。
常见泄漏:new[] 配 delete、new/delete 与 malloc/free 混用、异常路径没释放(缺 RAII)、容器存裸指针、shared_ptr 循环引用(用 weak_ptr 打破)、基类析构非虚。
一句话:看趋势 → 定区域 → 抓现场 → 先止血;泄漏 = 持续涨不回落,缓存不是;溢出 = 一次申请超上限。
11. 栈溢出、野指针、悬垂指针怎么产生?
Q: 常见的 C++ 内存错误?
栈溢出:递归过深或超大局部数组,耗尽栈空间撞到保护页 → SIGSEGV;
堆溢出:越界写堆对象→ 崩溃或安全漏洞;
野指针:指针没初始化,指向随机地址 → UB;
悬垂指针:指针仍然保存着某个对象的地址,但该对象已经失效或被释放。
- (来源:
delete/free后没有置nullptr、容器扩容导致旧元素地址失效、函数返回局部变量地址)
- (来源:
重复释放:
delete两次 → double free,堆损坏;内存泄漏:分配了没释放 → RSS 持续上涨。
防护:智能指针 + RAII、容器不存裸指针、基类析构虚、释放后置空
追问链:
- 野指针和悬垂指针区别?→ 野指针从没指向过有效对象;悬垂指针曾经有效、对象已销毁;
- 栈默认多大?→ Linux 通常 8MB(
ulimit -s),每线程独立; - UAF 为什么有时不崩?→ 内存还没被复用,但行为仍是 UB(未定义行为)
易错:delete 后指针不会自动置空**;栈溢出不一定是递归,也可能是超大局部数组。**
七、文件系统
1. 什么是 inode?为什么文件名不在 inode 里?
Q: inode 存了什么?为什么要有 inode?
inode 是文件系统里「一个文件的全套元数据 + 指向数据块的指针」,inode 号在同一文件系统内唯一。
inode 存:文件类型、权限、属主/属组、大小、链接数 nlink、数据块指针、引用计数。
inode 不存:
- 文件名——名字在**目录项(dentry)**里;
- 完整路径——路径是目录树走出来的;
- 文件数据本身——数据在数据块里。
为什么文件名不在 inode:文件名与inode解耦,才能支持硬链接(多个名字指向同一 inode)、改名只改目录项。
寻址链路:路径名 → 目录项 → inode 号 → inode → 数据块。
追问链:
- 目录是什么?→ 目录也是文件,内容是一组「文件名 → inode 号」的目录项。
- inode 会用完吗?→ 会,ext4 的 inode 总数在
mkfs时固定;满了磁盘有空间也建不了文件。 - inode 号唯一吗?→ 只在同一文件系统内唯一。
易错:
- inode 不含文件名,所以硬链接能成立。
- 「磁盘满了」不一定是数据块满,也可能是 inode 耗尽。
2. 硬链接和软链接的区别?
Q: 硬链接和软链接的本质区别?
| 维度 | 硬链接 ln | 软链接 ln -s |
|---|---|---|
| 本质 | 目录项指向同一 inode,链接数nlink +1 | 独立 inode,文件内容是目标路径字符串 |
| inode 号 | 相同 | 不同 |
| 跨文件系统 | ❌ | ✅ |
| 目标删除后 | 数据仍在(还有其他名字,链接数不为0) | 悬空,访问 ENOENT |
| 大小 | 目标文件大小 | 路径字符串长度 |
| 删除 | unlink 减链接计数 | unlink 删链接本身 |
硬链接是「同一个文件的多个名字」,软链接是「一个存着目标路径的小文件」。
追问链:
rm删的是什么?→ 删目录项(名字),nlink--;只有nlink == 0且没有打开的 fd 才真正释放数据。- 软链接的相对路径相对于谁?→ 相对于软链接所在目录,不是当前工作目录。
易错:
- 硬链接不能跨文件系统,因为 inode 号只在单个 FS 内唯一。
- 删除软链接不影响目标;删除目标会让软链接悬空。
3. VFS 的四大对象是什么?它们怎么协作?
Q: 什么是 VFS?superblock、inode、dentry、file 分别代表什么?
VFS 是内核的文件系统抽象层:应用统一调 open/read/write/stat,由 VFS 转发给 ext4、XFS、tmpfs 等具体文件系统。
四大对象(按职责记):
- superblock:一个已挂载的文件系统实例,记录块大小、inode 总数、空闲块等;
- inode:一个文件的元数据
- dentry:路径上的一个名字,记录「父目录 + 名字 → inode」,由 dcache 缓存;
- file:一次
open产生的打开文件描述,保存偏移量、打开标志、f_op。
fd 是进程 fd 表的下标 → 表项指向 struct file(一次打开)→ file 指向 dentry 和 inode → inode 属于某个 super_block。
- 多次
open同一文件 → 多个struct file; dup/fork→ 多个 fd 共享同一个struct file(偏移量共享)。
路径解析 open("/a/b/c"):
- 从 root dentry 或当前目录的 dentry 开始;
- 逐个名字查 dcache(父目录 + 名字 → dentry);
- 未命中就分配 dentry;
- 拿到最后一级 inode 后,分配
struct file,返回 fd。
negative dentry:确认「这个名字不存在」也会缓存,避免反复查底层文件系统。
追问链:
- 为什么
open比read贵?→open要逐级路径解析、权限检查、查 dentry/inode;read命中 Page Cache 只是拷贝(未命中时要磁盘 I/O,这个开销会比较大)。所以复用 fd 更高效; - VFS 怎么支持不同文件系统?→ 四个对象各带一张
*_operations函数表,ext4/XFS 各自实现,调用时多态分发。
易错:
- VFS 是抽象层,不是具体文件系统;
- dentry 在内存,磁盘上的目录项是目录文件里的数据,两者不是一回事;
- inode 缓存和 dentry 缓存是两套;
file也不是 inode,只是「一次打开」。
4. 文件描述符 fd 的本质是什么?
Q: fd 是什么?内核里怎么组织?dup/fork 后偏移量共享吗?
fd 是一个非负整数,是进程级文件描述符表的索引——不是文件本身,也不是 inode。
内核三层结构:
text
fd → 进程级 fd 表项 → 系统级打开文件表项 → inode 表项1
| 层 | 内容 | 共享范围 |
|---|---|---|
进程级 fd 表(files_struct) | fd 标志+ 指向打开文件表项的指针 | 同进程内不同线程共享 |
系统级打开文件表(struct file) | 当前文件偏移量、状态标志、指向 inode 的指针 | 全局,可被多个 fd/进程共享 |
| inode 表 | 文件类型、大小、权限、数据块、链接计数 | 全局 |
关键规则:
- 分配 fd 时返回当前最小可用的 fd;
- 两个 fd 是否共享偏移量,取决于是否指向同一个打开文件表项:
dup/dup2/fork后共享偏移;- 各自
open同一文件则独立偏移。
追问链:
close(fd)到底关了什么?→ 减「打开文件描述」的引用计数;最后一个引用关闭才真正断开/释放。- socket 也是 fd 吗?→ 是,
struct file->f_op = socket_file_ops,但没有磁盘 inode,inode在内存中存在。
易错:
- fd 不是 inode,也不是文件;只是进程 fd 表的下标。
- 父子进程
fork后共享偏移量,但各自 close 不影响对方(fd 表是复制的)。
5. 一次 read/write 在内核里走了什么路径?
Q:
read和write的完整流程?
读:read → VFS → 文件系统 → 在 inode 的 Page Cache 找页:
- 命中:
copy_page_to_iter到用户 buf; - 未命中:分配页 → DMA 从磁盘读入 Page Cache(可能预读)→ 拷贝到用户 buf。
写:write → 把用户数据拷进 Page Cache → 标记脏页 → 立即返回 → 后台 writeback 线程择机异步回写磁盘。
write 返回 ≠ 数据落盘。进程崩溃不丢(内核还在),掉电/内核崩溃会丢未回写的脏页;要持久化必须 fsync。
追问链:
read几次拷贝?→ 2 次:磁盘 → Page Cache(DMA),Page Cache → 用户 buf(CPU)。- 第一次读慢、第二次快?→ 第一次磁盘 I/O,第二次命中 Page Cache。
- 预读是什么?→ 检测到顺序读,提前读后续页;随机读会关闭/缩小预读。
易错:
- Page Cache 是可回收的,内存紧张时干净页被丢弃、脏页回写;
free小不代表泄漏。
6. Page Cache 是什么?脏页什么时候回写?
Q: Page Cache 的作用?脏页回写参数?
Page Cache:内核用空闲内存缓存文件页,以页(4KB)为单位,按 (inode, 页偏移) 索引;
同一文件被多个进程读,共享同一份缓存。
作用:减少磁盘 I/O;顺序读写命中时几乎全内存速度;支持预读、写合并。
脏页回写:三个触发条件
比例:脏页超过内存 10% 后台开始刷;超过 20% 写进程被同步阻塞——所以写入 burst 大时
write突然变慢,不一定是磁盘慢,而是被限流了;年龄:脏页超过 30s 必须回写;
周期:后台回写线程每 5s 醒一次检查。
一句话:后台异步刷 + 超阈值同步限流 + 定期兜底。
sync 回写所有文件系统;syncfs(fd) 只回写该 fd 所在文件系统;fsync(fd) 只保证这个文件;fdatasync(fd) 只保证数据 + 取回数据必需的元数据。
易错:
write返回只代表「数据进了 Page Cache」。fsync也不一定能刷设备硬件缓存(取决于设备是否撒谎/是否支持 FUA)。
7. fsync、fdatasync、O_DIRECT、O_SYNC 有什么区别?
write:默认只写进 Page Cache 就返回,不等于落盘;
Q: 怎么保证数据真正落盘?
三类:
fsync/fdatasync是「事后刷」:调用时把 Page Cache 里的脏页刷到磁盘;fsync(fd):刷数据 + 全部元数据,并让设备刷写缓存;fdatasync(fd):只刷数据 + 取回数据必需的元数据(如文件大小),比fsync快,适合日志追加;
O_SYNC/O_DSYNC是「写时刷」:每次write都等数据落盘才返回;O_SYNC:每次write都同步数据 + 元数据,最慢;O_DSYNC:每次write只同步数据 + 必需元数据,相当于fdatasync
O_DIRECT是「不走缓存」:绕过 Page Cache 直接和磁盘/设备缓存交互,但不保证持久化,要持久化仍需fsync。
追问链:
fsync返回就绝对安全吗?→ 设备可能撒谎(写缓存未刷),企业级盘要配合 FUA/barrier;- 数据库为什么用
O_DIRECT?→ 避免双重缓存(Buffer Pool + Page Cache),缓存交给应用层管理,自己控制持久化节奏
易错:
O_DIRECT≠ 持久化,仍需fsync;fsync(file)不保证rename后的目录项持久化,目录也要 fsync。
8. 文件系统崩溃一致性怎么保证?日志和 fsck 是什么?
Q: 掉电后文件系统怎么恢复?日志文件系统保证什么?
创建文件要改 inode 位图、inode、目录项等多处,这些写不是原子的,掉电可能不一致。
- fsck:事后全盘扫描修复,慢;
- 日志(WAL):先写「要改什么」到日志,提交后再改正式位置;崩溃后重放,**快,**避免每次全盘 fsck。
关键结论:日志保证元数据一致性和快速恢复,不等于数据持久化;数据持久化靠 fsync。
易错:日志文件系统 ≠ 数据不会丢;fsck 主要修元数据自洽(可能是旧数据),不保证用户数据完整。
9. df 和 du 为什么对不上?inode 耗尽怎么办?
Q: 磁盘满了,但
du统计很小,为什么?
df vs du:df 看文件系统——已分配块,含已删除但未释放的、保留块和元数据;du 看目录树——只累加可见文件。
对不上最常见的原因:文件 rm 了,但进程还持有 fd——目录项没了、nlink=0,但 inode 引用计数不为 0,数据块不释放。所以:df 不降、du 看不到;用 lsof +L1 找,关掉进程才释放。
inode 耗尽:建文件报 No space left on device——块和 inode 是两套资源。删小文件、迁移到别的 FS;ext4 的 inode 总数在 mkfs 时固定。
10. 怎么原子地写配置文件?
Q: 如何保证配置文件不被读到半写状态?
- 在目标文件同一目录建临时文件:(跨文件系统
rename会失败,退化成不原子的复制) - 写入完整内容;
fsync(temp_fd):持久化,否则崩溃后可能改名已生效、内容还没落盘;rename(temp, target):原子替换,读者要么看到旧文件要么看到新文件(如果用unlink+create中间有窗口);fsync(dir_fd):持久化,rename 是目录项修改,不刷目录,掉电后改名可能丢。
追问链:
rename是原子的吗?→ 同一文件系统内是原子的;跨文件系统不行。- 进程崩溃会丢吗?→ 不会,因为 Page Cache(内核)还在;掉电才会丢未 fsync 的数据。
易错:临时文件必须和目标同一文件系统;fsync(dir_fd) 经常被忘,导致掉电后改名丢失。
八、I/O 系统
1. 五种 I/O 模型是什么?
Q: 阻塞、非阻塞、多路复用、信号驱动、异步 I/O 的区别?
一次网络 I/O 分两阶段:① 等内核把数据准备好;② 把数据从内核拷到用户空间。
| 模型 | 阶段① 等数据 | 阶段② 拷贝 | 备注 |
|---|---|---|---|
| 阻塞 I/O | 阻塞 | 阻塞 | socket 默认;一连接一线程 |
| 非阻塞 I/O | 立即返回 EAGAIN,需轮询 | 阻塞 | 单独用烧 CPU |
| I/O 多路复用 | 阻塞在 select/poll/epoll | 阻塞 | 一个线程管多个 fd |
| 信号驱动 I/O | 不阻塞,等 SIGIO | 阻塞 | 编程复杂、兼容差,极少用 |
| 异步 I/O | 不阻塞 | 不阻塞 | 内核全干完再通知,io_uring |
判定标准:阶段②的拷贝由谁做。应用自己调 read 拷贝 → 同步 I/O;内核完成后通知 → 异步 I/O。所以 epoll 是同步 I/O 多路复用。
追问链:
- 非阻塞 + 轮询为什么不好?→ CPU 空转;必须配合多路复用才有意义。
- 信号驱动为什么少用?→ 标准信号会合并丢失,handler 里能安全调用的函数极少。
- io_uring 和 POSIX AIO 区别?→ POSIX AIO 实现弱、只适合存储;io_uring 统一网络 + 磁盘、批量提交、真正异步。
2. 同步/异步、阻塞/非阻塞、并发怎么区分?
Q: 这几组概念怎么区分?
一句话:阻塞/非阻塞说的是「等的时候阻不阻塞」,同步/异步说的是「数据谁来搬」。多线程 + 阻塞 I/O 是并发,每个线程内部仍是同步阻塞;Reactor 基于同步 I/O 多路复用,Proactor 才是异步。
易错:并发 ≠ 并行;异步 ≠ 非阻塞;epoll 不是异步 I/O,也不让 I/O 变快(它只减少等待成本,拷贝照旧)。
3. select、poll、epoll 有什么区别?
演进主线:数据结构 → 拷贝 → 检测方式。
| 维度 | select | poll | epoll |
|---|---|---|---|
| 数据结构 | 位图 fd_set | pollfd 数组 | 内核红黑树 + 就绪链表 |
| fd 上限 | 有,fd 值必须 < FD_SETSIZE(1024) | 无硬限制,受 ulimit -n | 无硬限制 |
| 拷贝 | 每次调用全量拷进+拷出,且每次要重置 | 每次调用全量拷贝 | epoll_ctl 注册时拷一次,之后不再传 |
| 检测方式 | 内核轮询 O(n) | 内核轮询 O(n) | 回调挂就绪链表,O(就绪数) |
| 取就绪 fd | 只返回数量,用户遍历集合 | 只返回数量,用户遍历集合 | epoll_wait 直接返回就绪数组 |
| 触发模式 | 仅 LT | 仅 LT | LT + ET |
| 平台 | 全平台 | 类 Unix | 仅 Linux |
要点:
- select 的 1024 是 fd 数值上限,不是连接数上限(0/1/2 被占用,实际约 1021)。
- poll 只解决了数量限制,拷贝和 O(n) 遍历没解决,性能模型与 select 同级。
- 选型:跨平台且连接少用 select;类 Unix 中等规模用 poll;Linux 高并发必须 epoll。
追问链:
- epoll 一定比 select 快吗?→ 连接少且都活跃时,``epoll_wait` 也要遍历就绪列表,优势不明显;高并发大量空闲连接才明显。
- select 的 fd_set 为什么每次要重置?→ 内核会修改它,返回后只保留就绪位,下次调用前要重新设置。
易错:
- select 的 1024 不是「最多 1024 个连接」,是 fd 值上限。
- poll 不是「O(1)」,仍是 O(n)。
4. epoll 的底层实现?为什么高效?
Q: epoll 的红黑树和就绪链表怎么工作?
三个 API + 两个结构:
epoll_create创建eventpoll对象,内含**红黑树 **(管理所有注册 fd,节点是epitem)+ **就绪双向链表 **;epoll_ctl对红黑树增删改(O(log n)),并给该 fd 注册回调;epoll_wait只看 就绪双向链表 空不空
事件驱动,不是轮询:数据到达时由协议栈回调 ep_poll_callback,通过 fd 找到 红黑树的epitem 挂进就绪链表。
为什么用红黑树:hash 无法预知 fd 数量(开大浪费开小不够);红黑树增删查 O(log n),比 AVL 旋转少、插入更快。
为什么就绪用双向链表:就绪集合不查找、无优先级,核心操作只有三种——尾插就绪节点、任意节点 O(1) 摘除、整体 O(1) 摘取遍历
线程安全:红黑树加锁**(内核实现)**,就绪链表加自旋锁(队列操作极短)。
追问链:
- epoll 快是因为 mmap 省拷贝吗?→ 不准确。省的不是就绪事件拷贝(
epoll_wait仍要把就绪事件拷到用户数组),而是不用每次重传全量 fd 列表。 - epoll 是 O(1) 吗?→ 近似:
epoll_wait与就绪数相关,epoll_ctl是 O(log n)。 - epoll 能监听普通文件吗?→ 不能,只能监听socket文件;普通文件总是「就绪」。
易错:
EPOLLERR/EPOLLHUP不用注册也会上报。- fd close() 前必须从 epoll 中 DEL,否则 fd 复用时事件错乱。
5. LT 和 ET 的区别?ET 为什么必须非阻塞?
Q: 水平触发和边缘触发的区别?ET 的编程要求?
| 维度 | LT(水平触发,默认) | ET(边缘触发) |
|---|---|---|
| 通知条件 | 只要缓冲区还有数据就反复通知 | 只在状态跳变(空→有数据)时通知一次 |
| 编程难度 | 低,不易丢数据 | 高,必须一次读干净 |
| 性能 | 有冗余通知 | 通知次数少,系统调用少 |
| 是否强制非阻塞 | 否 | 是 |
| 典型 | Redis 用 LT | Nginx 用 ET |
ET 必须非阻塞的逻辑:ET 要求循环 read 直到把缓冲区掏空 → 最后一次 read 时缓冲区已经空了 → 若是阻塞 IO 就永久挂起、线程卡死;非阻塞则立即返回 -1/EAGAIN,可以安全 break。
ET 下没读完会怎样:数据不会丢(还在内核缓冲区),但不会再收到通知,直到有新数据触发新的跳变——所以必须读到 EAGAIN。
ET 下 accept 也要循环:一次事件可能对应多个新连接,accept 要循环到 EAGAIN。
写事件的坑:LT 下只要 socket 可写就会一直返回,等于 busy loop。正确做法是平时不注册 EPOLLOUT,只在 send 返回 EAGAIN 时才注册,数据发完后立刻 EPOLL_CTL_MOD 取消。
send 返回 -1 且 errno == EAGAIN 代表:
- 当前这个 socket 暂时不能发送更多数据,内核发送缓冲区已满或对端接收窗口不足;这不是致命错误,应该稍后重试。
追问链:
- ET 一定比 LT 快吗?→ 连接少/数据少时差异不大。
- LT 会丢数据吗?→ 不会,没读完下次还会通知。
- ET 下
EPOLLRDHUP有什么用?→ 感知对端半关闭不再发数据后,及时处理。
易错:
- ET 不是「只通知一次就永远不通知」,是新数据到达还会通知。
- ET 下
accept不循环会漏连接。
6. 惊群是什么?怎么解决?
Q:惊群?
惊群:多个进程/线程等待同一事件,事件发生后内核唤醒全部,但只有一个能成功处理,浪费 CPU 和上下文切换。
Q: accept 惊群和 epoll 惊群?
- **accept 惊群:**多个 worker 直接调用
accept(listen_fd)阻塞,新连接到达时,会唤醒多个 accept 等待者 - epoll 惊群:多个 worker 各自
epoll_wait(epfd),且epfd都注册了同一个listen_fd,listen_fd可读时多个epoll_wait返回,多个 worker 被唤醒后去 accept
解决方案有四类:
| 方案 | 核心机制 | 主要缺点 |
|---|---|---|
| SO_REUSEPORT | 每个 worker 独立 listen socket + 独立 epoll,内核按哈希分发 | 不感知 worker 忙闲,可能分发不均 |
| EPOLLEXCLUSIVE | 多个 epoll 等同一 listen fd,内核只唤醒一个 | LIFO 可能导致低负载时连接集中 |
| accept_mutex | 用户态锁串行化 accept,抢到锁才 accept | 有锁竞争;nginx 已默认关闭 |
| 单线程 accept + fd 分发 | 主线程 accept 后,用 SCM_RIGHTS 或共享内存队列把 fd 给 worker | 有 IPC/同步开销;主线程可能成瓶颈 |
Muduo 的处理方式:默认不使用多 worker 抢 accept,而是用“单线程 accept + 轮询分发连接”从根源上避免惊群;
注意,服务器先 listen 再 accept ,按顺序考虑即可,listen 在多个线程中,不存在惊群(linux内核解决)
追问链:
SO_REUSEPORT 怎么负载均衡?→ 按四元组哈希,避免同一客户端大量连接可能集中到一个 worker
惊群不是「唤醒太多线程处理同一份数据」,而是「唤醒后只有一个能工作」。
7. Reactor 和 Proactor 的区别?
Q: Reactor/Proactor 的语义?Reactor 有哪几种线程模型?
| 维度 | Reactor | Proactor |
|---|---|---|
| I/O 模型 | 同步非阻塞 + 多路复用 | 异步 I/O |
| 通知语义 | 就绪事件:「可以读了」 | 完成事件:「我已经读完了」 |
| 谁做读写 | 应用自己 read/write | 内核完成,数据已放进用户缓冲区 |
| 典型 | Linux epoll、libevent、muduo、Netty | Windows IOCP、io_uring |
Reactor 线程模型:
| 模型 | 结构 | 问题/适用 |
|---|---|---|
| 单 Reactor 单线程 | 一个线程做 accept + 读写 + 业务 | 无法利用多核,Redis 属此类 |
| 单 Reactor 多线程 | Reactor 单线程监听分发,业务丢给 worker 池 | Reactor 本身仍是瓶颈 |
| 主从 Reactor 多线程 | MainReactor 只 accept,多个 SubReactor 各自 epoll 处理读写 | 高并发首选(nginx、Netty、muduo) |
追问链:
- Linux 为什么主流是 Reactor?→ 原生异步 I/O弱且只适合存储;io_uring 出现后 Linux 才真正能走 Proactor。
- muduo 的 one loop per thread 是什么?→ 一个 EventLoop 绑定一个线程,连接的所有操作都在该线程,几乎不用加锁。
8. 零拷贝是什么?sendfile、mmap、splice 怎么选?
Q: 零拷贝省了什么?各方案的区别?
零拷贝不是「一次拷贝都没有」——DMA 拷贝省不掉,省的是 CPU 拷贝和上下文切换。
基线场景:把文件通过 socket 发出去。
传统 read + write:4 次上下文切换 + 4 次拷贝(2 次 DMA + 2 次 CPU)。
| 方案 | 原理 | 上下文切换 | CPU 拷贝 | 限制 |
|---|---|---|---|---|
| read + write | 内核→用户→内核 | 4 | 2 | 数据经过用户态(一种浪费) |
| mmap + write | 映射 Page Cache 到用户空间,省掉「内核→用户」 | 4 | 1 | 大文件才划算;文件被截断会 SIGBUS |
| sendfile | 内核内直接 file→socket,不经用户态 | 2 | 0~1 | 不能修改数据(加密/压缩不行) |
| splice | 通过管道缓冲区在内核内搬数据 | 2 | 0 | 两端至少一端必须是管道;不需硬件支持 |
选型:
- 静态文件下载用 sendfile(nginx
sendfile on); - 需要对大文件做处理用 mmap;
- 管道/socket 之间转发用 splice。
追问链:
- mmap + write 为什么不是完全零拷贝?→ 仍需一次 CPU 拷贝到 socket 缓冲区。
- sendfile 为什么不能改数据?→ 数据不经过用户态;要处理就用 mmap 或用户态 buffer。
- 零拷贝和 Page Cache 什么关系?→ 零拷贝依赖内核的 Page Cache,文件页直接在内核挂到 socket 发送队列。
易错:
- 零拷贝不等于「0 次拷贝」,DMA 拷贝仍在。
- sendfile 只能文件 → socket,不能 socket → 文件。
9. io_uring 是什么?和 epoll 有什么区别?
Q: io_uring 的原理?什么时候用它?
io_uring 是 Linux 5.1+ 的真正异步 I/O(Proactor 语义),用 SQ/CQ 双环形队列 + mmap 共享内存,无锁生产者-消费者模型。
SQ/CQ 双环流程:应用填 提交队列项→ 通知内核 → 内核异步执行 → 写完成队列项,应用直接读结果(在用户态内存里),不需要再发 read/write 系统调用;
对比 epoll:
| epoll | io_uring | |
|---|---|---|
| 语义 | 就绪通知 | 完成通知 |
| 系统调用 | 每次请求至少 2 次(epoll_wait + read) | 0~1 次(可批量、可 SQPOLL) |
| 支持 | 主要是 socket/fd | 网络 + 磁盘 + 超时 + 批量 |
| 成熟度 | 高 | 较新,依赖内核版本 |
代价:API 复杂、缓冲生命周期/背压/完成顺序难处理、容器/内核版本限制。
追问链:
- io_uring 一定比 epoll 快吗?→ 不一定,普通业务 epoll 足够;海量小 I/O、磁盘异步、批量提交才有优势。
- SQPOLL 是什么?→ 内核线程轮询提交队列,应用无需每次 syscall,但占一个 CPU。
易错:
- io_uring 不是「epoll 的升级版」,语义不同(完成 vs 就绪)。
10. 网络缓冲区怎么设计?粘包怎么处理?
Q: muduo 的 Buffer 为什么分 prependable/readable/writable?
muduo Buffer 三段:
text
| prependable | readable | writable |
预留区 待处理数据 可写空间1
2
2
- prependable:在消息前加长度头时 O(1),不用搬移消息体;
- readable:已收到、待解析的数据;
- writable:剩余可写空间;
- 读指针/写指针移动,空间不足时扩容或搬移。
粘包/半包:
TCP 是字节流,不维护消息边界;「包」是应用层概念。
解决:
- 长度字段 Header + Body最常用
- 分隔符(
\r\n) - 定长
实现:接收缓冲区「够一条解析一条,不够就留着等下次数据」;解析失败要能回滚读指针;限制最大长度防攻击。
追问链:
- UDP 有粘包吗?→ 没有,面向数据报,保留消息边界。
- 为什么 Buffer 要支持 prepend?→ 加协议头时避免整体 memmove带来的开销。
11. 一个 epoll 实例最多能监听多少连接?瓶颈在哪?
Q: C10K/C100K/C10M 的瓶颈分别是什么?
epoll 本身没有固定上限(有 1024 硬限制的是 select)。上限取决于:
- fd 资源:
ulimit -n/fs.file-max; - 内存:每条连接占内核 socket 缓冲区 + 应用层缓冲区;
- CPU / 活跃比例:epoll 的 O(1) 是「O(就绪 fd 数)」,连接几乎全活跃时优势缩小;
- fd 用尽会怎样?→
accept返回EMFILE;要预留 fd + 限流告警,不能死循环 accept。
易错:
- epoll 不限制连接数,限制的是 fd/内存/CPU。
- 端口 65535 个是客户端临时端口限制,不是服务端。
12. 阻塞/非阻塞 socket 的返回值怎么处理?
Q: 阻塞和非阻塞 socket 读写的返回值有什么区别?EAGAIN、EINTR 分别怎么处理?
阻塞/非阻塞是 fd 的属性,socket 默认阻塞;
read返回值:
| 返回值 | 含义 | 处理 |
|---|---|---|
> 0 | 实际读的字节数 | 要循环;没写完的数据存应用层发送缓冲区,等 EPOLLOUT 再发 |
0 | 代表对端有序关闭(EOF) | 关闭 fd、从 epoll 摘除 |
-1 | 失败,必须看 errno | 见下表 |
-1 的 errno 里,只有一种「不是错误」:
| errno | 含义 | 处理 |
|---|---|---|
EAGAIN / EWOULDBLOCK | 非阻塞下未就绪 | 不是错误,等下一次事件;ET 模式必须循环读写到 EAGAIN 为止 |
EINTR | 被信号中断 | 直接重试(read/accept/epoll_wait 都会遇到) |
ECONNRESET | 对端 RST | 连接异常断开,关闭清理 |
EPIPE | 对端已关闭写方向 | 再写触发 SIGPIPE(默认杀进程)→ MSG_NOSIGNAL 或忽略 SIGPIPE |
阻塞 socket 只有「成功 / 失败」两态;非阻塞 socket 多了第三态「EAGAIN」—— 事件驱动 + 循环读写到 EAGAIN
易错:
read返回 0 是 EOF,不是 EAGAIN,别和「暂时没数据」混为一谈。write返回 0 在循环写里视为异常(正常至少写 1 字节),否则会死循环。
13. 磁盘 I/O 和网络 I/O 有什么不同?
Q: 为什么磁盘 I/O 不能直接丢进 epoll?
- 普通文件总是「就绪」,epoll 监听会返回
EPERM;read普通文件可能阻塞在 Page Cache 未命中上,卡住事件循环线程。 - 解法:把阻塞文件 I/O 放进单独的线程池(muduo 做法),或用 io_uring 做原生异步磁盘 I/O。
易错:epoll 不是「所有 fd 都能监听」,普通文件不行。
九、进程间通信
1. Linux 有哪些 IPC 方式?怎么选?
Q: 进程间通信方式对比和选型?
| 方式 | 速度 | 特征 | 亲缘要求 | 场景 |
|---|---|---|---|---|
| 匿名管道 | ★★★ | 字节流、内置阻塞、64KB 缓冲 | 需亲缘(fd 继承) | shell 管道 |
| 命名管道(FIFO) | ★★★ | 字节流、凭路径名相遇 | 无 | 无亲缘进程 |
| 消息队列 | ★★ | 有边界、带优先级、可异步通知 | 无 | 多生产者-消费者 |
| 共享内存 | ★★★★★ | 0 拷贝 0 syscall、需自己同步 | 无 | 高频大数据 |
| 信号 | ★★★★ | 只有编号、异步 | 需 PID/PGID | 进程控制/通知 |
| Unix Socket | ★★★★ | 本地、无网络栈开销、唯一能传 fd | 无 | 本地前后端 |
选型口诀:
- 本机大数据 → 共享内存 + 信号量;
- 父子流式 → 管道;
- 解耦异步 → 消息队列;
- 跨机 → Socket(本机用
AF_UNIX比 TCP 快)。
追问链:
- 共享内存为什么最快?→ 同一物理页挂进双方页表,读写就是普通内存访问,没有内核拷贝/切换。
- Unix Socket 为什么能传 fd?→ 内核在接收方 fd 表里复制一个指向同一打开文件表项的 fd。
- 消息队列和 socket 区别?→ 消息队列有边界/类型/优先级,但只能本机;socket 可跨机。
易错:
- 信号不传数据,且标准信号不排队。
2. 管道和 FIFO 的区别?
Q: 匿名管道和命名管道的区别?读写阻塞语义?
- 共同点:内核里的一块缓冲区,半双工、字节流无消息边界、FIFO、默认阻塞、用
read/write操作。 - 匿名管道
pipe(int fd[2]):无名字、不属于文件系统、不占磁盘;只能用于有亲缘关系的进程;进程退出自动释放。fd[0]读端、fd[1]写端。 - 命名管道
mkfifo:有路径名,以特殊文件形式存在;无亲缘关系的进程也能通信。
阻塞语义:
- 读空管道阻塞(直到有数据或写端全关);
- 写满管道阻塞;
- 写端全关 → read 返回 0(EOF);
- 读端全关 → write → SIGPIPE。
shell 管道骨架:
text
# 把 cmd1 的输出接到 cmd2 的输入
pipe(fd) → fork×2
子1:dup2(fd[1], 1) → close 原 fd → exec(cmd1)
子2:dup2(fd[0], 0) → close 原 fd → exec(cmd2)
父: close(fd[0]); close(fd[1]); wait×2 ← 两端全关【关键】1
2
3
4
5
2
3
4
5
追问链:
- 为什么父进程要关两端?→ 否则「至少还有一个写端开着」,cmd2 的 read 永远等不到EOF(文件结束 End Of File)。
- 管道容量多大?→ 默认 64KB(16 页);写满阻塞。
- 管道能双向吗?→ 半双工,两个方向都可以传,但同一时间只能传一个方向。
3. 共享内存为什么最快?怎么用?
Q: 共享内存的原理?POSIX 共享内存怎么创建?
- 把同一块物理内存映射进各进程虚拟地址空间,读写就是普通内存访问;
- 对比管道/消息队列:write(用户→内核)+ read(内核→用户)两次拷贝 + 4 次态切换;共享内存只有建映射时一次内核开销;
- 代价:内核不提供同步,必须自己加锁/信号量; 共享内存不随进程退出销毁,需显式删除
步骤:
text
shm_open(name, O_CREAT | O_RDWR, 0600) // 拿 fd,背后是 /dev/shm 的 tmpfs
ftruncate(fd, size) // 定大小
mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0)
shm_unlink(name) // 删除名字,最后一个映射关闭后释放1
2
3
4
5
2
3
4
5
匿名共享:mmap(MAP_SHARED | MAP_ANONYMOUS),仅亲缘进程可用。
追问链:
- 共享内存和 mmap 文件映射什么关系?→ 共享内存本质是 tmpfs(基于内存的临时文件系统) + mmap 共享映射。
- 怎么同步?→ POSIX 信号量(
sem_open/sem_wait/sem_post)或进程共享 mutex - 共享内存会泄漏吗?→ 会,
/dev/shm下残留文件占内存;
易错:
- 共享内存不是「把数据复制过去」,是**「同一物理页映射两次」**。
- 没有同步的共享内存会数据竞争。
4. 信号是什么?常见信号和处理注意事项?
Q: 信号机制?SIGKILL 和 SIGTERM 区别?handler 里能做什么?
信号是异步通知机制,只传编号不传数据。
常见信号:
| 信号 | 编号 | 说明 |
|---|---|---|
SIGHUP | 1 | 终端挂断/重载配置 |
SIGINT | 2 | Ctrl+C |
SIGKILL | 9 | 不可捕获/阻塞/忽略 |
SIGSEGV | 11 | 段错误 |
SIGPIPE | 13 | 写已关闭 socket |
SIGTERM | 15 | 可捕获,优雅退出 |
SIGCHLD | 17 | 子进程退出 |
SIGSTOP | 19 | 暂停,不可捕获 |
SIGCONT | 18 | 继续 |
TERM 是「请你退出」(可捕获 → 来得及清理);
KILL 不可捕获/忽略/阻塞——必须留一条 100% 有效的杀进程通道。
handler 里只能调 async-signal-safe 函数:write/read/_exit/kill 可以;printf/malloc/加锁 不行,会自己把自己锁死(。
追问链:
- 信号会排队吗?→ 标准信号不排队,多个同类型信号可能合并。
SIGCHLD为什么要 while waitpid?→ 信号不排队,多个子进程同退可能只触发一次。
5. Unix Domain Socket 有什么优势?
Q: AF_UNIX 和 TCP 本机回环比,快在哪?
- 不走网络栈/网卡:没有 IP/TCP 封装、校验和、路由开销;
- 无握手/挥手/TIME_WAIT;
- 可靠:
SOCK_STREAM可靠有序;SOCK_DGRAM本机不丢包、保序、保留边界; - 唯一能传 fd;原因:内核在消息传递过程中,直接操作了文件描述符表。
- 比 TCP 本机回环快约一倍。
| 类型 | 语义 |
|---|---|
SOCK_STREAM | 可靠有序字节流(本机 TCP,但无握手/TIME_WAIT) |
SOCK_DGRAM | 可靠、保序、保留边界(本机 UDP,但不丢包) |
SOCK_SEQPACKET | 面向连接 + 保留边界 |
追问链:
- 为什么 Nginx 和后端常见 Unix socket?→ 本机通信,省网络栈开销,延迟低。
- 能传 fd 有什么用?
- 它能将一个已经打开、已处于特定状态(如已建立连接、已锁定、已映射)的资源,从一个进程无缝地移交给另一个进程,而无需重新走一遍open打开文件或创建文件流程。
易错:
- Unix socket 不是「没有连接」,
SOCK_STREAM仍需 connect/accept。
十、socket 编程与内核网络路径
1. TCP socket 编程的完整流程?
Q: 服务端和客户端的 socket 调用顺序?
text
服务端 客户端
socket() 创建未连接 socket socket()
bind() 绑定本地 IP:port (通常不 bind,内核选临时端口)
listen() CLOSED → LISTEN,建两条队列
accept() 从全连接队列取一条已完成的连接 connect() SYN_SENT → ESTABLISHED
read/write 收发 read/write
close() FIN/四次挥手 close()1
2
3
4
5
6
7
2
3
4
5
6
7
socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0):只创建对象,不占端口、不建连;bind:绑本地地址 + 端口;listen(fd, backlog):状态变LISTEN,创建半连接队列和全连接队列;backlog是全连接队列上限accept4(...):从全连接队列取一条已完成握手的连接,返回新 fd;监听 fd 仍是LISTEN;connect:内核选临时端口 → 发 SYN → 等握手完成 →ESTABLISHED。
追问链:
- accept 返回时握手完成了吗?→ 完成了,返回的是 ESTABLISHED 连接;accept 只是“取一条”,
accept不参与握手 - 新 fd 继承监听 fd 的 NONBLOCK/CLOEXEC 吗?→ 不继承,用
accept4显式设置; connect失败返回什么?→ 对端没人监听 →ECONNREFUSED;无响应 →ETIMEDOUT;路由不可达 →ENETUNREACH
2. socket 在 Linux 里是什么?
Q: socket 是文件吗?内核里怎么表示?
fd只是 fd 表下标;struct file->f_op = socket_file_ops,所以read/write/close/poll都能用——socket fd 和open()的 fd 完全同构(可 dup、fork 继承、设FD_CLOEXEC、放入 epoll、SCM_RIGHTS传递);- socket 没有磁盘 inode,不参与 VFS 目录树
- epoll 监视的是 fd,不是“网络”。
追问链:
close()会立刻断开连接吗?→ 不会,减的是“打开文件描述”的引用;最后一个引用关闭才真正断开;shutdown(SHUT_WR)和 close 区别?→ shutdown 直接发 FIN(只关写方向),fd 仍可读;close 关闭整个 fd。
3. listen 的 backlog 和 accept 队列?
Q: backlog 是什么?队列满了会怎样?
- 半连接队列(SYN queue):存收到 SYN、尚未完成握手的连接;满了开
tcp_syncookies用无状态 cookie,否则丢弃等重传; - 全连接队列(accept queue):存握手完成、等
accept的连接;满了默认丢客户端最后的 ACK、重发 SYN-ACK;tcp_abort_on_overflow=1则回 RST。
4. 连接关闭:CLOSE_WAIT 和 TIME_WAIT 怎么排查?
- CLOSE_WAIT 堆积 = 应用 bug:对端已发 FIN,本端没
close。 - TIME_WAIT 是主动关闭方的正常状态:大量 TIME_WAIT 说明短连接多、且是本端主动关;改用连接池/长连接,或让客户端先关;
5. TCP 收发包在内核里走了什么路径?
Q: 一个包从网卡到应用 read,经历了什么?
一句话:网卡把包写进内核的内存 → 内核逐层解析 → 放进该 socket 的接收缓冲区 → 唤醒等这个 fd 的进程 → read 拷走。
发包反过来:send 先拷进发送缓冲区,内核再按窗口和拥塞控制发出去。
text
收:网卡 DMA → 硬中断(只通知)→ 软中断批量处理 → IP/TCP 解析 → socket 接收缓冲区 → 唤醒 read
发:send 拷进发送缓冲区 → 受 cwnd/rwnd/Nagle 限制 → 网卡 → 网络1
2
2
记住 3 点:
- 硬中断只负责通知,真正收包在软中断里批量做(所以高并发要调软中断/RPS)。
send()返回 ≠ 已发出 ≠ 对端收到,只代表拷进了内核发送缓冲区。- 缓冲区满:阻塞 fd 睡眠,非阻塞返回
EAGAIN——这是应用层做背压的地方。