Skip to content

操作系统 ​


一、操作系统概述与内核基础 ​

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,继续执行用户代码

为什么慢:真正工作的代码只有几条指令,代价全在模式切换 + 上下文保存恢复上,外加用户↔内核数据拷贝、cache/TLB 污染。

普通函数调用只是压栈跳转,不换特权级。

减少系统调用的手段:

  1. 用户态缓冲批量读写;
  2. mmap 代替反复 read/write;
  3. sendfile/splice 零拷贝;
  4. 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_FILESfd 表
CLONE_FScwd
CLONE_SIGHAND信号处理表
CLONE_THREAD同一线程组(tgid 相同)

另:CLONE_CHILD_CLEARTID → 线程退出时清 tid 并用 futex 唤醒 pthread_join。

追问链

  1. 子线程里 getpid() 返回什么?→ tgid(进程号),不是线程号。
  2. 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):

  1. fork 时不复制物理内存,只复制父进程的页表;
  2. 父子页表项指向同一批物理页,全部标为只读,物理页带引用计数;
  3. 任一方写 → 触发写保护缺页异常 → 内核 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,无法创建新进程。
  • 清理:
    1. 父进程及时 wait/waitpid;
    2. SIGCHLD handler 里循环 while (waitpid(-1, NULL, WNOHANG) > 0);——信号不排队,多个子进程同退可能只触发一次;
    3. signal(SIGCHLD, SIG_IGN) 让内核自动回收(Linux);
    4. 杀掉父进程,僵尸变孤儿被 init 收养;
    5. 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)
  内核空间
高地址

追问链:

  • .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 失效反而拖慢。

线程池为什么快:

  1. 复用线程,省掉创建/销毁(分配 ~8MB 栈 + clone 系统调用);
  2. 任务到达即刻执行,降低响应延迟;
  3. 固定上限,天然限流、便于监控。

追问链:

  • 线程池核心组件?→ 任务队列 + mutex + condition_variable + 工作线程循环 + stop 标志。
  • 任务队列满了怎么办?→ 阻塞提交 / 丢弃 / 抛异常 / 调用者执行(拒绝策略)。
  • 为什么执行任务时不能持锁?→ 否则所有 worker 串行,线程池退化。

易错:

  • 「线程越多并发越高」——错,超过核数后主要是切换开销。
  • 进程池不是「进程越多越好」,还受内存、fd、PID 限制。

11. 协程是什么?有栈和无栈有什么区别? ​

协程是一种用户态、可挂起和恢复的轻量级执行单元。它不像线程那样由操作系统内核调度,而是由程序里的运行时/调度器在用户态切换。一个线程上可以跑很多协程。

协程主要不是为了“让出 CPU”,而是:在等待 IO 等事件时,挂起当前协程,让同一个线程继续执行其他协程,避免整个线程被阻塞。

它解决的是:大量并发 IO 任务下,线程成本高、阻塞等待浪费线程的问题。

事件线程 + 阻塞 IO协程 + 非阻塞 IO
等待时谁被挂起整个线程当前协程
线程能不能干别的不能能,继续跑其他协程
并发单位成本高,一个连接一个线程低,一个连接一个协程
切换成本内核态,较贵用户态,较轻
调度方式抢占式,内核调度通常协作式,协程主动让出

Q: 协程和线程的区别?为什么切换快?C++20 协程是什么?

一句话:协程是用户态轻量级执行流,由用户程序/运行时调度,内核不可见,协作式(非抢占),只在 co_await/yield/I/O 阻塞时主动让出。

快的原因:

  1. 切换在用户态完成,无用户态/内核态切换;
  2. 不换页表、不刷 TLB;
  3. 只保存少量寄存器(百纳秒级);
  4. 单线程内协程串行执行,共享变量可不加锁。

代价:

  1. 一个协程阻塞会卡住整个线程;
  2. 单线程协程无法利用多核,必须「多线程 + 每线程多协程」;
  3. 不能被抢占,长计算会饿死同线程其他协程。
有栈协程(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 唤醒一个等的人(没人等/无竞争时这一步也可以省掉)

为什么高效:无竞争时 0 次系统调用;有竞争时在内核里挂起/唤醒。

追问链:

  • FUTEX_WAIT 为什么要传「期望值」?→ 防止「检查后发现要睡,但睡之前锁已被释放」的丢失唤醒窗口。
  • 条件变量和 futex 什么关系?→ glibc 的条件变量底层用 futex 实现睡眠/唤醒。
  • 怎么观察竞争程度?→ strace -f -c -e trace=futex,futex 次数越多说明真实竞争越激烈。

易错:

  • futex 不是「一把锁」,是内核提供的等待/唤醒原语,锁逻辑仍在用户态。

4. 读写锁是什么?有什么坑? ​

Q: 读写锁的语义?适合什么场景?

  • 读读并行:多个读者可同时持有读锁;
  • 读写互斥:读者和写者不能同时;
  • 写写互斥:写者独占。

适合读多写少。不适合写多、或临界区极短的场景(读写锁本身有开销)。

坑:

  1. 写者饥饿:读者源源不断,写者一直等;
  2. 锁升级死锁:持有读锁再申请写锁,若两个线程同时想升级,会互等对方的读锁释放;
  3. 实现开销:维护读者计数、写者等待队列,比普通 mutex 重。

追问链:

  • 读写锁能升级吗?→ C++ std::shared_mutex 不能原地升级,必须先释放读锁再申请写锁(中间可能被插队)。
  • 读多写少还有别的方案吗?→ RCU、COW、shared_ptr 原子读、分段锁。

易错:

  • 读写锁不是「读一定不阻塞」:有写者等待时,新读者可能被阻塞(写优先实现)。

5. 条件变量为什么必须配 mutex?wait 为什么必须放 while? ​

Q: condition_variable 的用法和原理?

配 mutex 的原因:

  1. 判断条件本身要读共享变量,必须受锁保护;
  2. wait 内部要原子地「释放锁 + 挂起」,否则会出现「判断完但还没睡,通知就来了」的丢失唤醒。

用 unique_lock 而非 lock_guard:wait 内部需要反复 unlock/lock,lock_guard 不支持中途解锁。

必须 while 而不是 if:

  1. 虚假唤醒:、会出现没有 notify 也返回;
  2. notify_all 唤醒多个线程后,先抢到锁的把条件消耗掉了,后来的线程醒来条件已不成立。
cpp
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, [&]{ return !queue.empty() || stop; });  // 内部就是 while

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,整条指令硬件原子。

三个问题:

  1. ABA:值 A→B→A,CAS 察觉不到中间变化。CAS 误判成功,导致结构损坏。
    • 解决:带版本号的指针(指针 + 计数器打包);
  2. 自旋开销:高竞争下反复失败空转 CPU。
  3. 只能保证单个变量的原子性,多变量无能为力。

追问链:

  • 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;   // 保证读到 42
  • 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;
    }
};

为什么简单:w 只有生产者写、r 只有消费者写 → 没有 CAS 竞争;唯一要小心的是「数据先写、下标后发布」,靠 release/acquire 配对保证。

  1. 需要维护多个字段的不变量的时候不该用无锁;
  2. 先加锁写对 → 压测确认锁是瓶颈 → 只把最热的点换成无锁。
  3. 低竞争、任务耗时长时,有锁队列更好(阻塞不烧 CPU)。

追问链:

  • 环形队列为什么要 2 的幂?→ % N 可优化成 & (N-1)。
  • 无锁队列满了怎么办?→ 返回 false、自旋、或覆盖最旧数据(取决于业务)。

易错:

  • SPSC 不需要 CAS

10. 锁的优化手段有哪些? ​

Q: 高并发下锁竞争严重,怎么优化?

  1. 缩小临界区:只保护共享数据;
  2. 降低锁粒度 / 线程本地化:分段锁、per-thread 计数最后汇总;
  3. 读写分离 / 无锁:读多写少用读写锁;计数用原子操作、单生产单消费用 SPSC 队列;

追问链:

  • 分段锁怎么选段数?→ 通常 2 的幂,按 hash 映射;段数太多浪费内存,太少竞争高。

易错:

  • 锁粒度不是越小越好:锁太多会增加开销和死锁风险。

五、死锁 ​

1. 死锁的定义和四个必要条件? ​

Q: 什么是死锁?四个必要条件是什么?

死锁:一组进程/线程互相等待对方持有的资源,形成循环等待,无外力永远无法推进。

四个必要条件(同时满足才可能死锁,破坏任一即可):

条件含义怎么破坏
互斥资源一次只能被一个持有资源共享/无锁结构
请求与保持持有资源的同时申请新资源一次性申请全部资源
不可剥夺资源不能被强行夺走允许抢占/超时释放
循环等待存在进程-资源的环统一加锁顺序

追问链:

  • 四个条件都满足一定死锁吗?→ 不一定。单实例资源有环即死锁;多实例资源有环只是可能,需要化判定。
  • 死锁和活锁、饥饿的区别?→ 死锁全员阻塞;活锁都在跑但白跑;饥饿是个别线程长期拿不到资源。

易错:

  • 四条件是必要条件,不是充分条件。
  • 「循环等待」是工程上最容易破坏的(统一锁序)。

2. 工程上怎么防死锁? ​

死锁是四个条件同时满足才可能发生的,所以工程上就是逐条破坏:少共享 → 定顺序 → 一次拿 / 拿不到就退,用超时日志兜底。

一、设计上:能不共享就不共享(破「互斥」)

  • 用 std::atomic、thread_local、分段锁、无锁队列;
  • 一句话:没有共享就没有锁,没有锁就不会死锁。

二、加锁上:三条铁律

  1. 定顺序:所有线程按同一个顺序加锁(如按地址/ID 升序)——破「循环等待」,最有效;

  2. 一次拿:多把锁用 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);
  3. 拿不到就退:try_lock_for 设超时,失败就释放已持有的锁再重试——破「请求与保持」。

三、代码纪律:持锁时间要短,且必须保证解锁

  • 缩小临界区:持锁不调用外部回调、不做 I/O、不嵌套加锁;
  • RAII:lock_guard / unique_lock,异常路径也能自动解锁;
  • 不锁升级:读锁里不要再申请写锁。

四、兜底:加锁带超时 + 日志记录「谁在持锁」,线上出问题能直接定位。


3. 线上死锁怎么排查? ​

Q: 进程卡死了,怎么判断是不是死锁?

  1. pstack <pid> 连打两三次,或 gdb -p <pid> 后 thread apply all bt;
  2. 找栈一直不变且停在 pthread_mutex_lock / __lll_lock_wait / futex 的线程;
  3. 若线程 A 持锁 X 等 Y、线程 B 持锁 Y 等 X → 判定死锁,回代码找加锁顺序不一致;
  4. 兜底:加锁超时 + 日志打印「谁在持锁」,比事后查栈快。

追问链:

  • 死锁和线程池耗尽怎么区分?→ 死锁的线程栈停在锁上且不变;线程池耗尽通常栈停在任务等待/条件变量。

六、内存管理 ​

1. 什么是虚拟内存?为什么需要它? ​

Q: 虚拟内存的作用?

虚拟内存是 OS 给每个进程的私有、连续、独立的地址空间抽象:进程只看到虚拟地址,由 MMU + 页表翻译成物理地址。

三个作用:

  1. 隔离与保护:进程间互不可见,PTE 带 R/W/X 权限,越权访问直接段错误;
  2. 容量扩展:按需分页 + swap,可用空间可超过物理内存;
  3. 简化管理:malloc 只需拿一段连续虚拟地址,物理页框可以离散;

2. 虚拟地址怎么翻译成物理地址?为什么要多级页表? ​

Q: 虚拟地址怎么翻译成物理地址?

地址 → 逐级查表 → 拼物理地址。

  1. 拆:x86-64 实际只有 48 位有效虚拟地址(高 16 位符号扩展),按 4KB 页拆成 36 位虚拟页号 VPN + 12 位页内偏移;
  2. 查:MMU 从 CR3 拿到页表基址,用 VPN 逐级查页表,最后一级表项里存的就是物理页号 PFN;
  3. 拼:物理地址 = 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: 访问一个不在物理内存的页,过程是什么?

  1. CPU 访问一个虚拟地址;TLB 未命中,MMU 去查页表(PTE 有效则装入 TLB 直接返回);
  2. 发现 PTE 无效或权限不符(未分配 / 已换出 / COW / 越权访问)→ 触发缺页异常,陷入内核;
  3. 内核确认地址合法,非法 → SIGSEGV;
  4. 有空闲页框就分配;没有就选牺牲页——脏页先写回磁盘;更新牺牲页的 PTE 并清掉它的 TLB 项;
    • 牺牲页就是缺页时被页面置换算法选中、从物理内存中换出以腾出页帧的那个页
  5. 读入所需页,更新 PTE(P=1、填 PFN)并写入 TLB;
  6. 重新执行被中断的那条指令(不是下一条)。

追问链:

  • 缺页和普通中断的区别?→ 缺页是同步异常,处理完重执行原指令;
  • 缺页一定是坏事吗?→ 不是,按需分页 / 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 匿名映射
  • 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: 线上内存持续上涨,怎么定位?

  1. 确认是不是泄漏:看进程 RSS 是否单调上涨不回落;free 小但 available 大是 Page Cache,不算;
  2. 定位区域:top/ps 找到进程,pmap -x、/proc/PID/smaps_rollup 看是 [heap]、mmap 区还是文件缓存;
  3. 抓现场:测试环境用 valgrind / ASan(越界、UAF 也能查);生产用 tcmalloc/jemalloc heap profiler,两个时间点快照做 diff;
  4. 先止血: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"):

  1. 从 root dentry 或当前目录的 dentry 开始;
  2. 逐个名字查 dcache(父目录 + 名字 → dentry);
  3. 未命中就分配 dentry;
  4. 拿到最后一级 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 表项
层内容共享范围
进程级 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: 如何保证配置文件不被读到半写状态?

  1. 在目标文件同一目录建临时文件:(跨文件系统 rename 会失败,退化成不原子的复制)
  2. 写入完整内容;
  3. fsync(temp_fd):持久化,否则崩溃后可能改名已生效、内容还没落盘;
  4. rename(temp, target):原子替换,读者要么看到旧文件要么看到新文件(如果用unlink+create 中间有窗口);
  5. 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 有什么区别? ​

演进主线:数据结构 → 拷贝 → 检测方式。

维度selectpollepoll
数据结构位图 fd_setpollfd 数组内核红黑树 + 就绪链表
fd 上限有,fd 值必须 < FD_SETSIZE(1024)无硬限制,受 ulimit -n无硬限制
拷贝每次调用全量拷进+拷出,且每次要重置每次调用全量拷贝epoll_ctl 注册时拷一次,之后不再传
检测方式内核轮询 O(n)内核轮询 O(n)回调挂就绪链表,O(就绪数)
取就绪 fd只返回数量,用户遍历集合只返回数量,用户遍历集合epoll_wait 直接返回就绪数组
触发模式仅 LT仅 LTLT + 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 用 LTNginx 用 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 有哪几种线程模型?

维度ReactorProactor
I/O 模型同步非阻塞 + 多路复用异步 I/O
通知语义就绪事件:「可以读了」完成事件:「我已经读完了」
谁做读写应用自己 read/write内核完成,数据已放进用户缓冲区
典型Linux epoll、libevent、muduo、NettyWindows 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内核→用户→内核42数据经过用户态(一种浪费)
mmap + write映射 Page Cache 到用户空间,省掉「内核→用户」41大文件才划算;文件被截断会 SIGBUS
sendfile内核内直接 file→socket,不经用户态20~1不能修改数据(加密/压缩不行)
splice通过管道缓冲区在内核内搬数据20两端至少一端必须是管道;不需硬件支持

选型:

  • 静态文件下载用 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:

epollio_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 |
  预留区        待处理数据   可写空间
  • prependable:在消息前加长度头时 O(1),不用搬移消息体;
  • readable:已收到、待解析的数据;
  • writable:剩余可写空间;
  • 读指针/写指针移动,空间不足时扩容或搬移。

粘包/半包:

  • TCP 是字节流,不维护消息边界;「包」是应用层概念。

  • 解决:

    • 长度字段 Header + Body最常用
    • 分隔符(\r\n)
    • 定长
  • 实现:接收缓冲区「够一条解析一条,不够就留着等下次数据」;解析失败要能回滚读指针;限制最大长度防攻击。

追问链:

  • UDP 有粘包吗?→ 没有,面向数据报,保留消息边界。
  • 为什么 Buffer 要支持 prepend?→ 加协议头时避免整体 memmove带来的开销。

11. 一个 epoll 实例最多能监听多少连接?瓶颈在哪? ​

Q: C10K/C100K/C10M 的瓶颈分别是什么?

epoll 本身没有固定上限(有 1024 硬限制的是 select)。上限取决于:

  1. fd 资源:ulimit -n / fs.file-max;
  2. 内存:每条连接占内核 socket 缓冲区 + 应用层缓冲区;
  3. 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          ← 两端全关【关键】

追问链:

  • 为什么父进程要关两端?→ 否则「至少还有一个写端开着」,cmd2 的 read 永远等不到EOF(文件结束 End Of File)。
  • 管道容量多大?→ 默认 64KB(16 页);写满阻塞。
  • 管道能双向吗?→ 半双工,两个方向都可以传,但同一时间只能传一个方向。

3. 共享内存为什么最快?怎么用? ​

Q: 共享内存的原理?POSIX 共享内存怎么创建?

  1. 把同一块物理内存映射进各进程虚拟地址空间,读写就是普通内存访问;
  2. 对比管道/消息队列:write(用户→内核)+ read(内核→用户)两次拷贝 + 4 次态切换;共享内存只有建映射时一次内核开销;
  3. 代价:内核不提供同步,必须自己加锁/信号量; 共享内存不随进程退出销毁,需显式删除

步骤:

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)                          // 删除名字,最后一个映射关闭后释放

匿名共享:mmap(MAP_SHARED | MAP_ANONYMOUS),仅亲缘进程可用。

追问链:

  • 共享内存和 mmap 文件映射什么关系?→ 共享内存本质是 tmpfs(基于内存的临时文件系统) + mmap 共享映射。
  • 怎么同步?→ POSIX 信号量(sem_open/sem_wait/sem_post)或进程共享 mutex
  • 共享内存会泄漏吗?→ 会,/dev/shm 下残留文件占内存;

易错:

  • 共享内存不是「把数据复制过去」,是**「同一物理页映射两次」**。
  • 没有同步的共享内存会数据竞争。

4. 信号是什么?常见信号和处理注意事项? ​

Q: 信号机制?SIGKILL 和 SIGTERM 区别?handler 里能做什么?

信号是异步通知机制,只传编号不传数据。

常见信号:

信号编号说明
SIGHUP1终端挂断/重载配置
SIGINT2Ctrl+C
SIGKILL9不可捕获/阻塞/忽略
SIGSEGV11段错误
SIGPIPE13写已关闭 socket
SIGTERM15可捕获,优雅退出
SIGCHLD17子进程退出
SIGSTOP19暂停,不可捕获
SIGCONT18继续

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()
  • 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 限制 → 网卡 → 网络

记住 3 点:

  1. 硬中断只负责通知,真正收包在软中断里批量做(所以高并发要调软中断/RPS)。
  2. send() 返回 ≠ 已发出 ≠ 对端收到,只代表拷进了内核发送缓冲区。
  3. 缓冲区满:阻塞 fd 睡眠,非阻塞返回 EAGAIN——这是应用层做背压的地方。