Linux 操作系统面试八股总结(嵌入式 Linux C/C++ 应用开发)

一、操作系统基础与内核架构

1. 操作系统的作用是什么?

一句话回答:

操作系统是管理计算机硬件资源、为应用程序提供运行环境和系统服务的软件,核心职责包括资源管理、权限隔离和硬件抽象。

主要功能:

  1. 进程管理:负责进程创建、调度、切换和终止。

  2. 内存管理:负责内存分配、虚拟内存、地址映射和内存保护。

  3. 文件系统:提供统一的文件访问接口,管理文件和存储设备。

  4. 设备管理:通过驱动程序管理硬件设备。

  5. 网络管理:提供网络协议栈和 Socket 通信接口。

  6. 进程间通信:提供管道、共享内存、消息队列等通信机制。

核心思想:

操作系统通过抽象和隔离,让应用程序不必直接管理复杂的硬件资源。

例如:

  • 将 CPU 抽象为进程和线程。

  • 将物理内存抽象为虚拟地址空间。

  • 将磁盘抽象为文件。

  • 将网络通信抽象为 Socket。

2. 什么是用户态和内核态?为什么要区分?

一句话回答:

用户态和内核态是 CPU 的两种执行权限级别,区分它们是为了保护操作系统内核和硬件资源,避免普通应用程序直接执行特权操作。

用户态:

  • 运行普通应用程序。

  • 不能直接执行特权指令。

  • 不能随意访问内核空间。

  • 需要通过系统调用请求内核服务。

内核态:

  • 运行操作系统内核代码。

  • 可以执行特权指令。

  • 可以管理内存、设备、中断和进程。

  • 可以访问受保护的内核资源。

以 x86 为例,CPU 提供 Ring 0~Ring 3 权限级别,Linux 内核主要运行在 Ring 0,普通应用运行在 Ring 3。

ARM 处理器则采用不同的异常级别设计,例如 AArch64 中的 EL0 和 EL1。

为什么要区分?

假设应用程序可以随意修改页表、关闭中断或者访问其他进程的内存,那么一个普通程序的错误就可能导致整个系统崩溃。

通过权限隔离,可以限制应用程序的操作范围,提高系统安全性和稳定性。

3. 用户态如何进入内核态?

一句话回答:

主要有三种途径:系统调用、异常和中断。

  1. 系统调用:用户程序主动请求内核服务。

  2. 异常:CPU 执行指令时发生的同步事件,例如缺页异常、除零异常。

  3. 中断:外部硬件设备产生的异步事件,例如网卡收包、定时器中断。

系统调用的过程:

以 read() 为例:

  1. 用户程序调用 read() 库函数。

  2. C 库通过系统调用指令进入内核。

  3. CPU 切换到内核权限级别。

  4. 内核检查参数和文件描述符。

  5. 执行实际读取操作。

  6. 将结果返回用户空间。

  7. 恢复用户态执行。

注意:调用 read() 不代表一定发生磁盘读取。如果数据已经在 Page Cache 中,可能直接从缓存返回。

4. 系统调用和普通函数调用有什么区别?

一句话回答:

普通函数调用通常在用户态完成,而系统调用需要通过特定指令进入内核态,请求操作系统提供服务。

对比普通函数调用系统调用
执行位置通常在用户态涉及内核态
权限切换不需要需要
开销通常较小通常更大
功能应用程序自身逻辑请求内核服务

例如:

  • strlen():普通库函数。

  • memcpy():普通库函数。

  • read():系统调用接口。

  • write():系统调用接口。

  • open():系统调用接口。

注意:C 库函数不一定都是普通函数,也不一定每次都执行系统调用。例如 printf() 通常先写入用户态缓冲区,必要时才调用 write()。

5. 什么是上下文切换?

一句话回答:

上下文切换是 CPU 从一个执行任务切换到另一个执行任务的过程,需要保存当前任务的执行状态,并恢复另一个任务的执行状态。

主要过程:

  1. 保存当前任务的寄存器状态。

  2. 保存程序计数器 PC、栈指针 SP 等信息。

  3. 调度器选择下一个任务。

  4. 恢复目标任务的执行上下文。

  5. 继续执行目标任务。

上下文切换的开销:

  • 保存和恢复寄存器。

  • 调度器执行开销。

  • 可能涉及地址空间切换。

  • 可能造成 TLB 和 CPU Cache 命中率下降。

进程切换通常可能涉及页表切换,而同一进程内的线程切换通常不需要切换地址空间。

但要注意,现代 CPU 可以使用 ASID、PCID 等机制减少地址空间切换带来的 TLB 刷新,并非每次进程切换都必须清空整个 TLB。

面试追问:进程切换和线程切换哪个开销大?

通常进程切换开销更大,因为进程拥有独立地址空间,切换时可能需要更换页表;同一进程内线程共享地址空间,通常不需要更换页表。


二、进程、线程与协程

6. 什么是进程?

一句话回答:

进程是程序的一次执行实例,是操作系统进行资源分配和保护的重要单位。

进程包含哪些资源?

  • 独立的虚拟地址空间。

  • 代码段、数据段、堆和栈。

  • 文件描述符表。

  • 信号处理相关信息。

  • 进程控制信息。

  • 一个或多个线程。

Linux 内核使用 task_struct 描述任务,保存进程或线程的管理信息。

7. 什么是线程?

一句话回答:

线程是进程中的执行流,是 CPU 调度的基本单位,同一进程内的线程共享进程的大部分资源,但拥有各自独立的栈和寄存器上下文。

线程共享的资源:

  • 代码段。

  • 全局变量和静态变量。

  • 堆内存。

  • 文件描述符表。

  • 进程地址空间。

线程独立的资源:

  • 线程栈。

  • 寄存器状态。

  • 程序计数器。

  • 线程局部存储 TLS。

  • 线程 ID。

8. 进程和线程有什么区别?

对比进程线程
资源分配独立地址空间等资源共享所属进程资源
调度进程内的线程被调度线程是调度实体
地址空间相互隔离同进程线程共享
通信通常使用 IPC可以直接共享内存
切换通常开销较大同进程线程切换通常较小
崩溃影响通常不会直接影响其他进程未处理的致命错误通常导致整个进程终止

如何选择?

  • 需要强隔离:使用多进程。

  • 需要高效共享数据:使用多线程。

  • 需要充分利用多核 CPU:可以使用多进程或多线程。

9. 什么是协程?和线程有什么区别?

一句话回答:

协程是由用户态调度器管理的执行单元,通常在用户态完成切换,不需要每次切换都进入内核。

对比进程线程协程
调度者内核内核用户态调度器
资源独立地址空间共享进程资源共享线程资源
切换通常开销较大涉及内核调度通常开销较小
并行执行可以可以取决于运行时和线程调度方式

协程的优势是能够以较低的切换成本管理大量并发任务。

但协程不一定能自动利用多核 CPU,也不意味着所有协程都是协作式调度,具体取决于运行时实现。

10. 进程有哪些状态?

一句话回答:

Linux 进程常见状态包括运行、可中断睡眠、不可中断睡眠、停止和僵尸状态。

状态含义
R运行或就绪,处于运行队列中
S可中断睡眠,等待事件
D不可中断睡眠,通常等待某些内核资源或 IO
T停止状态
Z僵尸状态
I空闲内核线程状态

注意:

  • R 不代表一定正在 CPU 上运行,也可能只是等待调度。

  • S 状态可以被信号唤醒。

  • D 状态通常不能被普通信号直接唤醒。

  • Z 状态表示进程已经退出,但退出信息尚未被父进程回收。

11. fork() 创建子进程的原理是什么?

一句话回答:

fork() 创建一个子进程,子进程获得父进程地址空间的逻辑副本,Linux 通常通过写时复制(COW)机制避免立即复制所有物理内存。

执行过程:

  1. 调用 fork()。

  2. 内核创建子进程的任务描述结构。

  3. 为子进程建立相应的地址空间和页表映射。

  4. 父子进程暂时共享相应的物理内存页。

  5. 当某一方尝试写入共享页时,触发写时复制。

  6. 内核分配新的物理页并复制原数据。

  7. 修改写入方的页表映射,继续执行写操作。

fork() 返回值:

  • 父进程:返回子进程 PID。

  • 子进程:返回 0。

  • 创建失败:返回 -1。

为什么 fork() 比直接复制整个进程内存快?

因为采用 COW 后,不需要立即复制所有物理内存,只需要建立必要的管理结构。真正发生写入时才复制对应页面。

12. 什么是写时复制(COW)?

一句话回答:

写时复制是一种延迟复制机制,多个进程先共享物理内存,只有发生写操作时才复制对应内存页。

应用场景:

  • fork() 创建子进程。

  • 某些内存映射场景。

  • 共享资源的延迟复制。

优势:

减少不必要的内存复制,提高资源利用率。

13. fork() 后父子进程共享哪些资源?

一句话回答:

父子进程拥有逻辑上独立的地址空间,但初始时可以通过 COW 共享物理内存页;文件描述符等资源也会通过相应机制复制或共享底层对象。

需要特别注意文件描述符:

fork() 后,父子进程拥有各自的文件描述符表,但对应描述符通常指向同一个 open file description,因此共享文件偏移量和文件状态标志。

例如父进程读取文件后,子进程继续读取,可能从父进程更新后的偏移位置开始。

14. fork() 和 exec() 有什么区别?

一句话回答:

fork() 创建新进程,exec() 用新的程序映像替换当前进程的用户空间内容。

fork():

创建子进程,子进程从 fork 返回位置继续执行。

exec():

  • 替换当前进程的代码段、数据段、堆和栈。

  • 通常保留 PID。

  • 默认保留未设置 FD_CLOEXEC 的文件描述符。

  • 成功时不会返回原程序。

常见使用方式:

pid_t pid = fork();

if (pid == 0) {
    execlp("ls", "ls", "-l", NULL);
    perror("execlp");
    _exit(127);
} else if (pid > 0) {
    waitpid(pid, NULL, 0);
}

15. 什么是僵尸进程和孤儿进程?

僵尸进程:

子进程已经退出,但父进程没有调用 wait() 或 waitpid() 回收其退出状态,导致内核保留其退出信息。

孤儿进程:

父进程先于子进程退出,子进程会被系统中的相应收养进程接管,现代 Linux 通常由 PID 1 或指定的 subreaper 收养。

如何处理僵尸进程?

  1. 父进程调用 wait()。

  2. 使用 waitpid() 回收指定子进程。

  3. 通过 SIGCHLD 通知父进程回收。

  4. 对于不需要获取退出状态的子进程,可以使用适当的 SIGCHLD 忽略处理方式。

常见写法:

while (waitpid(-1, NULL, WNOHANG) > 0) {
    // 回收已经退出的子进程
}

16. 多线程程序调用 fork() 有什么问题?

一句话回答:

多线程进程调用 fork() 后,子进程只保留调用 fork 的线程,其他线程不会出现在子进程中,但它们可能持有的锁状态会被继承,从而导致子进程死锁。

解决方式:

多线程程序 fork 后,子进程应尽量立即调用 exec(),在 exec 之前只调用异步信号安全的函数。


三、进程调度

17. 常见的进程调度算法有哪些?

算法核心思想特点
FCFS先来先服务实现简单,可能出现护航效应
SJF短作业优先平均等待时间较短,长任务可能饥饿
优先级调度高优先级优先可能产生低优先级饥饿
RR时间片轮转适合分时系统
MLFQ多级反馈队列根据任务行为动态调整优先级

18. Linux 使用什么调度策略?

一句话回答:

Linux 普通任务采用公平调度体系,实时任务则支持 FIFO 和 RR 等实时调度策略。

传统 Linux CFS 的核心思想是使用虚拟运行时间 vruntime,尽量公平地分配 CPU。

  • vruntime 越小,越倾向于获得 CPU。

  • nice 值影响调度权重。

  • 权重越高,虚拟运行时间增长越慢。

补充:较新的 Linux 内核逐步引入 EEVDF 调度机制,不能把所有现代 Linux 内核都简单描述成传统 CFS 红黑树实现。

实时调度策略:

  • SCHED_FIFO:高优先级实时任务可以持续运行,直到阻塞、主动让出或被更高优先级任务抢占。

  • SCHED_RR:同优先级实时任务之间使用时间片轮转。

19. 什么情况下会发生进程调度?

  1. 当前任务时间片耗尽。

  2. 当前任务主动阻塞,例如等待 IO。

  3. 当前任务主动调用 sched_yield()。

  4. 更高优先级任务就绪。

  5. 当前任务退出。

20. 什么是 CPU 亲和性?

一句话回答:

CPU 亲和性是限制进程或线程可以在哪些 CPU 核心上运行的机制。

Linux 提供:

taskset -c 0,1 ./app

也可以通过:

sched_setaffinity();

设置线程或进程的 CPU 亲和性。

优点:

  • 减少 CPU 核心迁移。

  • 提高 Cache 局部性。

  • 在部分实时场景下提高执行可预测性。

缺点:

  • 可能造成 CPU 负载不均衡。

  • 降低调度器灵活性。


四、进程间通信 IPC

21. Linux 常见的进程间通信方式有哪些?

通信方式特点适用场景
匿名管道 pipe半双工字节流,通常用于亲缘进程父子进程通信
命名管道 FIFO通过文件系统名称访问无亲缘关系进程通信
消息队列按消息传递,有消息边界消息交互
共享内存多进程共享同一段物理内存高频、大数据量通信
信号量计数型同步机制资源同步
信号异步事件通知进程通知
Socket双向通信本机或跨主机通信

22. 共享内存为什么速度快?

一句话回答:

共享内存允许多个进程映射同一物理内存区域,进程之间可以直接读写这块内存,不需要像普通管道通信那样通过内核缓冲区反复传递数据。

基本流程:

  1. 创建共享内存区域。

  2. 将共享内存映射到各进程地址空间。

  3. 各进程直接访问共享区域。

  4. 使用互斥锁、信号量或原子变量保证同步。

  5. 使用完成后解除映射并释放资源。

常见接口:

  • shm_open()。

  • ftruncate()。

  • mmap()。

  • shm_unlink()。

也可以使用 System V IPC:

  • shmget()。

  • shmat()。

  • shmdt()。

  • shmctl()。

注意:

共享内存本身不负责同步。多个进程同时修改共享数据时,仍然可能出现竞态条件。

23. 共享内存和管道有什么区别?

共享内存:

  • 多个进程直接访问同一块内存。

  • 数据传递开销较低。

  • 需要自行解决同步问题。

  • 适合大数据量和高频通信。

管道:

  • 通过内核管理的缓冲区传输数据。

  • 接口简单。

  • 不需要自己管理共享内存的读写位置。

  • 适合简单的数据流通信。

24. 什么是 Unix Domain Socket?

一句话回答:

Unix Domain Socket 是 Linux 提供的本机进程间通信机制,可以使用类似 Socket 的接口在同一台机器上的进程之间通信。

特点:

  1. 支持双向通信。

  2. 不需要经过 TCP/IP 网络协议栈。

  3. 支持字节流和数据报等通信类型。

  4. 可以通过 SCM_RIGHTS 传递文件描述符。

  5. 可以通过 SO_PEERCRED 获取对端进程凭证。

为什么它通常比 TCP loopback 更适合本机通信?

因为它不需要完整的 TCP/IP 路由和传输层处理,减少了部分协议栈开销。

25. 什么是信号?信号处理函数有什么限制?

一句话回答:

信号是一种异步通知机制,用于通知进程发生了某种事件。

常见信号:

信号含义
SIGINT终端中断
SIGTERM请求进程终止
SIGKILL强制终止,不能捕获或忽略
SIGSEGV非法内存访问
SIGCHLD子进程状态发生变化
SIGPIPE向已关闭的管道或 Socket 写入

信号处理函数的注意事项:

信号处理函数可能在程序执行任意位置被打断,因此不能随意调用非异步信号安全函数。

例如,不应直接在处理函数中调用:

  • printf()。

  • malloc()。

  • free()。

  • 复杂的 C++ 对象操作。

工程上可以采用:

  • self-pipe。

  • signalfd()。

  • 专门的信号处理线程配合 sigwait()。

26. 什么是 mmap?有什么用途?

一句话回答:

mmap() 可以将文件或匿名内存映射到进程虚拟地址空间,使程序能够像访问普通内存一样访问映射区域。

函数原型:

void *mmap(
    void *addr,
    size_t length,
    int prot,
    int flags,
    int fd,
    off_t offset
);

常见用途:

  1. 文件映射:将文件映射到内存,方便随机访问。

  2. 共享内存:多个进程映射同一个对象。

  3. 匿名映射:申请匿名虚拟内存。

  4. 大文件处理:避免反复使用 read/write 进行数据拷贝。

MAP_SHARED 和 MAP_PRIVATE:

  • MAP_SHARED:修改映射内容可以影响共享对象,文件映射的修改可以通过相应机制回写。

  • MAP_PRIVATE:采用写时复制,修改不会作为共享修改传播到其他映射。


五、内存管理与虚拟内存

27. 什么是虚拟内存?为什么需要虚拟内存?

一句话回答:

虚拟内存是操作系统为每个进程提供的独立逻辑地址空间,通过 MMU 和页表将虚拟地址转换为物理地址。

主要作用:

  1. 内存隔离:进程不能随意访问其他进程的内存。

  2. 简化编程:每个进程拥有独立的虚拟地址空间。

  3. 内存保护:通过页表设置读、写、执行权限。

  4. 内存共享:不同进程可以映射同一物理页面。

  5. 支持按需分配:只有实际访问时才可能分配物理内存。

28. 进程的虚拟地址空间如何划分?

典型 Linux 用户进程的虚拟地址空间可以抽象为:

高地址
+----------------------+
|      内核空间         |
+----------------------+
|      线程栈           |
|                      |
|      mmap 映射区      |
|      共享库           |
|                      |
|      堆               |
+----------------------+
|      BSS 段           |
|      DATA 段          |
|      TEXT 段          |
+----------------------+
低地址

各区域作用:

  • TEXT:存放程序指令,通常具有可读和可执行权限。

  • DATA:存放已初始化的全局变量和静态变量。

  • BSS:存放未初始化或零初始化的全局变量和静态变量。

  • HEAP:动态内存分配区域。

  • STACK:保存函数调用信息、局部变量等。

  • mmap 区域:映射共享库、文件和匿名内存等。

注意:实际布局受 CPU 架构、ASLR、内核配置和程序运行情况影响,并非所有区域都严格按照示意图排列。

29. 什么是分页机制?

一句话回答:

分页机制将虚拟地址空间和物理内存划分为固定大小的页,通过页表建立虚拟页到物理页框的映射。

例如常见的 4KB 页面:

虚拟地址可以拆分为:

+----------------+--------------+
|    虚拟页号     |   页内偏移    |
+----------------+--------------+

页内偏移决定页面内部的位置,虚拟页号用于查询页表。

30. 什么是多级页表?为什么需要多级页表?

一句话回答:

多级页表通过分层组织页表项,避免为整个虚拟地址空间一次性分配庞大的连续页表。

如果使用单级页表,庞大的虚拟地址空间会导致页表占用大量内存。

多级页表只需要为实际使用的地址区域分配对应层级的页表。

优点:

减少页表内存占用。

缺点:

地址转换可能需要多次访问内存,因此需要 TLB 加速。

31. 什么是 TLB?

一句话回答:

TLB 是 CPU 中用于缓存虚拟地址到物理地址映射关系的高速缓存。

地址转换过程:

  1. CPU 访问虚拟地址。

  2. MMU 查询 TLB。

  3. 命中则直接获得物理地址。

  4. 未命中则通过页表进行地址转换。

  5. 将映射结果缓存到 TLB。

TLB 可以显著减少页表查询带来的访存开销。

32. 什么是缺页异常(Page Fault)?

一句话回答:

缺页异常是 CPU 访问虚拟地址时,发现当前页表映射不满足访问要求而触发的异常,内核需要判断原因并处理。

常见处理情况:

  1. 地址合法,但页面尚未分配:分配物理页。

  2. 文件映射页面尚未加载:从 Page Cache 或存储设备获取。

  3. COW 页面被写入:分配新页面并复制数据。

  4. 地址非法:通常向进程发送 SIGSEGV 或 SIGBUS。

Minor Fault:

不需要从存储设备读取数据就能完成的缺页处理。

Major Fault:

需要进行实际存储设备 IO 才能完成的缺页处理。

33. 什么是页面置换算法?

当物理内存不足时,操作系统需要选择页面进行回收或换出。

常见算法:

算法核心思想
FIFO淘汰最早进入内存的页面
LRU淘汰最长时间未使用的页面
OPT淘汰未来最长时间不会使用的页面
Clock利用访问位实现近似 LRU
LFU淘汰访问频率较低的页面

Linux 使用多种页面回收机制,不能简单认为实际内核只采用某一种经典算法。

34. malloc() 的底层原理是什么?

一句话回答:

malloc() 是 C 标准库提供的动态内存分配接口,通常通过用户态内存分配器管理内存,必要时通过 brk() 或 mmap() 等机制向内核申请虚拟内存。

大致流程:

  1. 应用程序调用 malloc()。

  2. 分配器检查已有空闲内存块。

  3. 如果有合适的内存块,直接分配。

  4. 如果没有,可能向内核申请更多虚拟内存。

  5. 返回可供程序使用的地址。

brk() 和 mmap():

  • brk():调整进程传统堆区域的边界。

  • mmap():创建新的内存映射区域。

glibc 会根据分配大小、分配器策略和线程竞争等因素选择不同的管理方式。

为什么 free() 后进程占用内存不一定下降?

因为 free() 通常只是将内存归还给用户态分配器的空闲管理结构,不一定立即归还内核。

35. 什么是内存碎片?

内部碎片:

分配的内存块大于实际需要,产生浪费。

外部碎片:

空闲内存总量足够,但被分割成不连续的小块,难以满足较大的连续分配请求。

常见优化:

  • 内存池。

  • 对象池。

  • 固定大小内存块。

  • slab 类分配器。

  • jemalloc、tcmalloc 等分配器。

36. 什么是 OOM Killer?

一句话回答:

当系统内存压力严重、内核无法通过回收等方式满足内存需求时,Linux OOM Killer 会选择进程终止,以缓解内存不足问题。

可以查看:

dmesg | grep -i oom

对于嵌入式设备,需要特别关注:

  • 系统剩余内存。

  • 进程 RSS。

  • 内存泄漏。

  • 内存碎片。

  • 内核内存占用。

  • OOM 日志。

37. 如何排查 Linux 程序内存持续增长?

常用工具:

# 查看整体内存
free -h

# 查看进程内存
ps -o pid,rss,vsz,comm -p <pid>

# 查看进程内存映射
pmap -x <pid>

# 查看进程状态
cat /proc/<pid>/status

# 使用 Valgrind
valgrind --leak-check=full ./app

常见原因:

  1. 内存泄漏:申请后没有释放。

  2. 缓存持续增长:没有设置容量上限。

  3. 分配器没有及时将空闲内存归还内核。

  4. 内存碎片。

  5. 线程栈和 mmap 映射区域增加。

注意:

RSS 表示进程当前驻留在物理内存中的页面总量,并不等于进程独占的物理内存。共享页面会被多个进程的 RSS 重复统计。


六、并发与同步

38. 什么是竞态条件?

一句话回答:

竞态条件是多个线程或进程并发访问共享资源,最终结果依赖执行时序,导致程序行为不确定的情况。

例如:

int count = 0;

// 两个线程同时执行
count++;

count++ 并不是原子操作,可能出现丢失更新。

39. 什么是临界区?

一句话回答:

临界区是访问共享资源的代码区域,同一时刻需要按照设计要求限制并发访问,避免数据竞争。

例如:

pthread_mutex_lock(&mutex);

count++;

pthread_mutex_unlock(&mutex);

40. 常见同步机制有哪些?

同步机制原理适用场景
互斥锁互斥访问保护共享数据
自旋锁忙等待锁极短临界区
读写锁多读单写读多写少
条件变量等待条件成立生产者消费者
信号量计数同步资源数量控制
原子操作不可分割的操作计数器、状态标记
futex用户态快速路径,竞争时进入内核高效同步

41. 互斥锁和自旋锁有什么区别?

互斥锁:

获取不到锁时,线程可以进入阻塞状态,等待锁释放。

自旋锁:

获取不到锁时,线程持续循环检查锁状态,不主动睡眠。

对比互斥锁自旋锁
等待方式阻塞等待忙等待
CPU 消耗等待时通常不持续占用 CPU持续占用 CPU
适用场景临界区可能较长临界区极短
切换开销可能产生睡眠唤醒开销可能避免睡眠切换

注意:

用户态自旋锁在单核 CPU 上尤其需要谨慎。如果持锁线程无法获得运行机会,自旋线程可能一直等待。

42. 什么是条件变量?为什么要配合互斥锁?

一句话回答:

条件变量用于让线程等待某个共享条件成立,通常配合互斥锁使用,以保证条件检查和等待过程的正确性。

标准使用方式:

pthread_mutex_lock(&mutex);

while (queue.empty()) {
    pthread_cond_wait(&cond, &mutex);
}

// 取出任务

pthread_mutex_unlock(&mutex);

为什么必须使用 while 而不是 if?

  1. 条件变量可能发生虚假唤醒。

  2. 多个线程可能同时被唤醒。

  3. 线程被唤醒后,条件可能已经被其他线程改变。

所以必须重新检查条件。

43. 互斥锁和信号量有什么区别?

互斥锁:

主要用于互斥访问共享资源,通常由加锁的线程负责解锁。

信号量:

本质上是一个计数器,用于控制资源数量或者线程之间的同步。

常见类型:

  • 二值信号量。

  • 计数信号量。

例如限制同时访问某个资源的线程数量,可以使用计数信号量。

44. 什么是 CAS?有什么问题?

一句话回答:

CAS 是 Compare And Swap,即比较并交换,通过比较内存中的值与预期值是否一致,决定是否执行更新。

基本过程:

  1. 读取当前值。

  2. 比较当前值与预期值。

  3. 相等则更新为新值。

  4. 不相等则更新失败,通常重新读取并重试。

存在的问题:

  • ABA 问题。

  • 高竞争时不断自旋。

  • 内存回收问题。

  • 需要正确的内存序保证。

45. 什么是 ABA 问题?

一句话回答:

ABA 问题是指一个变量从 A 变成 B,又变回 A,CAS 只比较当前值时无法发现中间发生过变化。

解决方法:

给变量附加版本号,每次修改都更新版本号。

例如:

(A, version=1)
    ↓
(B, version=2)
    ↓
(A, version=3)

即使值重新变成 A,版本号也已经改变。

46. 什么是死锁?产生死锁的四个必要条件是什么?

一句话回答:

死锁是多个线程或进程互相等待对方持有的资源,导致所有参与者都无法继续执行的状态。

四个必要条件:

  1. 互斥:资源只能被一个任务占用。

  2. 占有并等待:持有资源的同时继续等待其他资源。

  3. 不可剥夺:资源不能被强制抢走。

  4. 循环等待:多个任务之间形成循环等待关系。

如何避免死锁?

  • 固定加锁顺序。

  • 尽量减少嵌套加锁。

  • 使用 trylock()。

  • 设置超时。

  • 缩小临界区。

  • 避免持锁执行耗时操作。

47. 什么是生产者消费者模型?

一句话回答:

生产者消费者模型通过共享缓冲队列连接数据生产者和消费者,生产者负责产生数据,消费者负责处理数据,两者通过同步机制协调工作。

典型场景:

嵌入式 Linux 视频处理:

摄像头采集线程
       |
       v
    数据队列
       |
       v
   编码处理线程
       |
       v
    数据队列
       |
       v
   网络发送线程

需要解决的问题:

  1. 队列为空时消费者等待。

  2. 队列满时生产者等待或丢弃数据。

  3. 多线程访问队列需要同步。

  4. 退出时需要唤醒阻塞线程。

  5. 需要明确数据所有权和生命周期。

48. 什么是内存屏障?

一句话回答:

内存屏障用于约束特定内存操作的执行顺序,防止编译器或 CPU 的重排序破坏并发程序的正确性。

为什么需要?

现代 CPU 为了提升性能,可能进行乱序执行、写缓冲等优化;编译器也可能重排指令。

在多核系统中,如果缺乏正确的同步机制,可能导致一个线程观察到的数据顺序与预期不一致。

嵌入式开发注意:

ARM 通常采用弱内存序模型,不能仅凭 x86 上测试正常,就认为并发代码在 ARM 上也一定正确。

应优先使用 C/C++ 原子操作、互斥锁等标准同步机制,而不是随意手写屏障指令。

49. 什么是伪共享?

一句话回答:

伪共享是指多个 CPU 核心修改不同变量,但这些变量位于同一个 Cache Line 中,导致缓存一致性机制频繁使缓存行失效。

解决方式:

  • 适当填充结构体。

  • 将高频写入变量分开放置。

  • 使用缓存行对齐。

  • 减少多核之间共享写变量。

常见 CPU Cache Line 大小为 64 字节,但具体大小取决于处理器。


七、文件系统与 IO

50. Linux 文件系统的基本组成是什么?

一句话回答:

Linux 通过 VFS(虚拟文件系统)提供统一的文件访问接口,再由具体文件系统实现文件管理和数据存储。

主要概念:

  • VFS:统一文件操作接口。

  • inode:保存文件元数据。

  • dentry:目录项,维护文件名与 inode 的关联。

  • file:描述一次打开的文件实例。

  • superblock:描述文件系统整体信息。

  • page cache:缓存文件数据页面。

51. 什么是 inode?

一句话回答:

inode 是文件系统中描述文件元数据的数据结构,通常保存文件权限、大小、时间戳和数据块相关信息。

inode 不直接保存文件名。

目录项负责建立文件名与 inode 之间的关联。

52. 硬链接和软链接有什么区别?

对比硬链接软链接
本质指向同一 inode独立文件,保存目标路径
inode相同不同
跨文件系统不支持支持
目标删除后只要仍有硬链接,文件数据仍存在可能变成断链

53. read() 和 write() 的工作过程是什么?

read():

  1. 用户程序调用 read。

  2. 进入内核。

  3. 内核根据文件描述符找到对应文件对象。

  4. 读取数据。

  5. 将数据复制到用户空间。

  6. 返回实际读取字节数。

write():

  1. 用户程序调用 write。

  2. 进入内核。

  3. 内核检查文件描述符和写入权限。

  4. 将用户数据写入内核管理的缓存或设备路径。

  5. 返回实际写入字节数。

注意:read() 和 write() 都可能发生短读、短写,也可能被信号中断,需要根据返回值处理。

54. write() 成功就代表数据已经写入磁盘了吗?

一句话回答:

不代表。普通文件的 write() 通常只是将数据写入 Page Cache,真正的数据持久化可能在后续异步回写阶段完成。

常见同步接口:

  • fsync():同步文件数据和相关元数据。

  • fdatasync():主要同步文件数据及读取数据所必需的元数据。

  • sync():请求系统同步文件系统数据。

如果应用需要可靠的持久化,还需要考虑文件系统、设备写缓存和硬件是否正确支持持久化保证。

55. 什么是 Page Cache?

一句话回答:

Page Cache 是 Linux 内核用于缓存文件数据的内存区域,可以减少重复访问存储设备的开销。

读操作:

  1. 先检查 Page Cache。

  2. 命中则直接使用缓存数据。

  3. 未命中则触发相应的文件读取。

  4. 读取完成后将数据缓存。

写操作:

  1. 数据通常先进入 Page Cache。

  2. 对应页面被标记为脏页。

  3. 内核后台执行回写。

  4. 根据同步要求完成持久化。

56. 什么是 O_DIRECT 和 O_SYNC?

O_DIRECT:

尽可能绕过 Page Cache 进行直接 IO,通常存在地址、长度和偏移对齐要求。

O_SYNC:

要求写操作按照同步 IO 语义完成后再返回,具体持久化保证仍取决于设备和文件系统实现。

适用场景:

当应用程序需要自行管理缓存或对写入持久性有特殊要求时,可以研究这些机制。

57. 文件描述符是什么?

一句话回答:

文件描述符是进程文件描述符表中的一个非负整数索引,用于引用内核管理的打开文件对象。

Linux 中很多资源都可以通过文件描述符操作:

  • 普通文件。

  • Socket。

  • 管道。

  • 设备文件。

  • epoll 实例。

  • eventfd。

这也是 Linux 一切皆文件思想的重要体现。

58. select、poll 和 epoll 有什么区别?

select:

  • 使用 fd_set 描述关注的文件描述符。

  • 有 FD_SETSIZE 等限制。

  • 每次调用通常需要重新设置集合。

  • 内核需要检查关注集合中的描述符。

poll:

  • 使用 pollfd 数组。

  • 没有 select 那种固定 FD_SETSIZE 限制。

  • 每次调用仍需要传递关注集合。

  • 内核需要遍历关注的描述符。

epoll:

  • 使用事件注册机制。

  • 通过 epoll_ctl 注册和修改关注事件。

  • 通过 epoll_wait 获取就绪事件。

  • 适合大量连接的 IO 多路复用场景。

核心区别:

select 和 poll 每次调用都需要传递关注集合,epoll 则通过内核维护的事件兴趣列表减少重复传递和检查工作。

59. 什么是 IO 多路复用?

一句话回答:

IO 多路复用允许一个线程同时监视多个文件描述符的 IO 状态,当某个描述符就绪时再执行对应的读写操作。

常见接口:

  • select。

  • poll。

  • epoll。

适用场景:

  • 高并发网络服务器。

  • 多客户端 Socket 通信。

  • 设备事件处理。

  • 统一管理多个 IO 源。


八、中断与网络 IO

60. 什么是硬中断和软中断?

硬中断:

由硬件设备触发,CPU 暂停当前执行流程,转而执行相应的中断处理程序。

软中断:

由内核安排执行的延迟处理机制,通常用于处理不适合完全放在硬中断上下文中的任务。

例如网络收包过程中,网卡可以触发硬中断,随后由软中断机制处理后续网络协议栈工作。

61. 什么是中断上半部和下半部?

上半部:

在硬中断上下文中快速完成必要操作,例如确认中断、记录事件、唤醒后续处理。

下半部:

将耗时工作推迟处理,常见机制包括:

  • Softirq。

  • Tasklet(已逐步被其他机制替代)。

  • Workqueue。

注意:Workqueue 通常运行在进程上下文,可以睡眠;Softirq 运行在软中断上下文,不能随意睡眠。

62. 为什么网络高负载时软中断 CPU 占用率会很高?

一句话回答:

因为大量网络数据包需要内核网络协议栈处理,收发包相关的软中断处理工作会消耗大量 CPU。

可以通过以下命令排查:

top
cat /proc/softirqs
cat /proc/interrupts

优化方向:

  • RSS:网卡硬件分配收包队列。

  • RPS:软件层面分散收包处理。

  • RFS:尽量将收包处理分配到应用所在 CPU。

  • XDP:在较早阶段处理数据包。

  • 调整网卡队列和中断亲和性。

63. Linux 中有哪些常见时钟?

CLOCK_REALTIME:

系统日历时间,可能受到 NTP 校时等影响。

CLOCK_MONOTONIC:

单调递增时钟,不会因为系统日历时间被调整而倒退,适合计算超时和时间间隔。

CLOCK_BOOTTIME:

与 MONOTONIC 类似,但会将系统休眠时间计算在内。

在网络通信、心跳检测和超时控制中,通常优先使用 CLOCK_MONOTONIC。


九、虚拟化与容器

64. 什么是虚拟机?

一句话回答:

虚拟机通过 Hypervisor 对硬件资源进行虚拟化,使多个独立操作系统能够运行在同一台物理机器上。

每个虚拟机通常拥有自己的 Guest OS 内核。

65. 什么是容器?

一句话回答:

容器是基于 Linux 内核提供的隔离和资源控制机制构建的轻量级运行环境,多个容器通常共享宿主机内核。

核心技术:

  1. Namespace:隔离进程、网络、挂载点等资源视图。

  2. Cgroups:限制和统计 CPU、内存、进程数等资源。

  3. Union Filesystem:提供分层文件系统。

66. Namespace 有哪些类型?

类型隔离内容
PID进程 ID
NET网络栈
MNT挂载点
UTS主机名和域名
IPC进程间通信资源
USER用户和用户组 ID 映射
CGROUPCgroup 视图
TIME系统时间视图

67. Cgroups 有什么作用?

一句话回答:

Cgroups 用于对一组进程进行资源限制、统计和控制。

常见资源:

  • CPU:限制 CPU 使用量或权重。

  • Memory:限制内存使用。

  • PIDs:限制进程数量。

  • IO:控制块设备 IO。

  • cpuset:限制 CPU 和内存节点范围。

68. 容器和虚拟机有什么区别?

对比虚拟机容器
内核独立 Guest OS共享宿主内核
隔离方式硬件虚拟化内核隔离机制
启动速度通常较慢通常较快
资源开销通常较大通常较小
隔离边界通常更强依赖宿主内核

十、Linux 系统性能排查

69. CPU 使用率 100%,如何排查?

排查流程:

第一步:确定哪个进程占用 CPU。

top

第二步:查看进程内部哪个线程占用 CPU。

top -H -p <pid>

第三步:查看 CPU 热点函数。

perf top -p <pid>

第四步:查看系统调用情况。

strace -c -p <pid>

常见原因:

  • 死循环。

  • 自旋等待。

  • 锁竞争。

  • 频繁系统调用。

  • 频繁内存分配。

  • 网络收发包压力过大。

  • 软中断处理过重。

70. Load Average 很高,但 CPU 使用率不高,为什么?

一句话回答:

Linux Load Average 不仅统计正在运行和等待 CPU 的任务,还统计不可中断睡眠状态的任务,因此大量 IO 等待也可能导致 Load Average 升高。

排查:

ps -eo state,pid,comm | awk '$1=="D"'
iostat -x 1
iotop

71. 如何排查程序运行过程中偶发卡顿?

主要从三个方向排查:

  1. CPU:是否存在 CPU 竞争、线程调度延迟或 CPU 限流。

  2. 内存:是否发生缺页、内存回收或频繁分配。

  3. IO:是否存在磁盘等待、网络重传或阻塞读写。

常用工具:

top
vmstat 1
iostat -x 1
pidstat -w 1
perf top

对于实时视频系统,还应重点关注:

  • 采集队列是否堆积。

  • 编码耗时是否突然增加。

  • 网络发送是否阻塞。

  • 接收缓冲区是否积压。

  • 视频帧是否出现丢失。

72. 常用 Linux 性能分析工具有哪些?

工具作用
top查看系统和进程资源占用
ps查看进程信息
free查看内存使用情况
vmstat查看系统整体运行状态
iostat查看磁盘 IO
pidstat查看进程 CPU、内存和 IO
strace跟踪系统调用
lsof查看进程打开的文件
perfCPU 性能分析
pmap查看进程内存映射
Valgrind内存错误与泄漏检测
GDB调试程序和分析崩溃

十一、面试高频场景题

73. 一个进程和多个线程应该如何选择?

优先考虑数据共享需求、故障隔离要求、任务并行性和资源开销。

如果需要独立地址空间和故障隔离,考虑多进程;如果任务需要高频共享数据,通常优先考虑多线程。

74. 为什么多线程程序会出现数据不一致?

因为多个线程并发访问共享变量时,如果缺少正确的同步机制,可能发生数据竞争、丢失更新和可见性问题。

可以使用互斥锁、读写锁或原子操作解决。

75. 为什么共享内存通常比管道快?

共享内存允许进程直接访问同一物理内存区域,减少了数据在内核缓冲区和用户空间之间的反复传递。

76. 为什么 malloc 申请成功,实际使用时却可能失败?

因为 malloc 成功不一定意味着所有对应物理页面都已经分配。Linux 可能采用内存超配策略,实际访问页面时才发生缺页和物理内存分配。

77. 为什么 free() 后 RSS 不一定下降?

因为内存分配器可能将释放的内存保留在用户态缓存或空闲链表中,以便后续重复分配,不一定立即归还内核。

78. 为什么大量创建线程会影响程序性能?

因为线程创建和销毁需要系统资源,线程数量过多会增加栈内存占用、调度开销和上下文切换,并可能造成锁竞争。

工程中通常采用线程池控制线程数量。

79. 为什么 write() 可能返回的字节数小于请求的字节数?

因为系统调用允许短写,可能受到信号中断、资源限制、文件类型和设备状态等因素影响。

应用程序需要根据返回值循环处理剩余数据,必要时处理 EINTR 和 EAGAIN。

80. 为什么不能在信号处理函数中随意调用 printf()?

因为 printf() 不是异步信号安全函数,可能与被中断代码中的 stdio 内部状态或锁产生冲突。

应该在信号处理函数中只做最小操作,将真正工作交给主循环或专门线程。

81. 嵌入式 Linux 程序为什么需要关注内存碎片?

嵌入式设备通常内存容量有限,长期运行过程中如果频繁动态申请和释放不同大小的内存,可能造成碎片和分配失败。

可以通过内存池、对象池、固定大小缓冲区和合理的数据生命周期管理改善。

82. 如何设计一个稳定的多线程视频处理程序?

建议采用流水线设计:

V4L2 采集
    |
    v
采集缓冲区
    |
    v
编码线程
    |
    v
有界数据队列
    |
    v
网络发送线程

需要重点考虑:

  1. 每个模块的线程职责。

  2. 队列容量上限。

  3. 满队列时的丢帧或阻塞策略。

  4. 缓冲区所有权。

  5. 线程安全。

  6. 超时和异常处理。

  7. 退出时的资源回收。

  8. 端到端延迟统计。


十二、面试速记表

问题核心答案
操作系统作用资源管理、隔离、硬件抽象
用户态和内核态不同 CPU 权限级别
系统调用用户程序请求内核服务
上下文切换保存和恢复任务执行状态
进程资源分配和保护单位
线程内核调度实体
协程用户态调度的执行单元
fork创建子进程
COW写入时才复制页面
exec替换当前进程程序映像
僵尸进程已退出但尚未回收退出信息
孤儿进程父进程先退出的子进程
虚拟内存虚拟地址到物理地址的映射
页表保存地址映射关系
TLB缓存地址映射
缺页异常页面映射或访问权限需要处理
malloc用户态内存分配接口
mmap将对象映射到虚拟地址空间
共享内存多进程映射同一物理内存
互斥锁保护临界区
条件变量等待共享条件成立
信号量计数同步
CAS比较并交换
ABA值变化后又恢复原值
死锁任务之间循环等待资源
Page Cache文件数据缓存
fsync请求同步文件数据和相关元数据
inode文件元数据
epollIO 多路复用
硬中断硬件触发的中断
软中断内核延迟处理机制
Namespace资源视图隔离
Cgroups资源限制与统计

十三、面试学习建议

对于嵌入式 Linux C/C++ 应用开发岗位,建议优先掌握以下知识:

第一优先级:

  • 进程和线程。

  • fork、exec、waitpid。

  • 进程间通信。

  • 线程同步。

  • 死锁。

  • 虚拟内存。

  • malloc、mmap。

  • 文件描述符。

  • select、poll、epoll。

  • 信号和 IO。

第二优先级:

  • Page Cache。

  • 文件系统和 inode。

  • 中断与软中断。

  • CPU 调度。

  • 上下文切换。

  • 内存屏障。

  • 性能分析工具。

第三优先级:

  • 容器与 Namespace。

  • Cgroups。

  • NUMA。

  • EEVDF。

  • 无锁数据结构。

  • XDP/eBPF。

学习操作系统不要只背概念,尽量结合 Linux API 和实际代码理解机制。

例如:

  • 学进程:自己实现 fork、exec、waitpid。

  • 学线程:使用 pthread 实现线程池。

  • 学 IPC:分别实现共享内存和 Unix Domain Socket 通信。

  • 学内存:通过 mmap 实现文件映射。

  • 学 IO:使用 epoll 实现多客户端服务器。

  • 学性能分析:通过 perf、strace、GDB 分析实际程序。

最终目标是能够解释:应用程序执行某个操作时,用户态和内核态分别发生了什么,以及资源是如何被管理和调度的。

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐