面试高频考点 01：volatile / 中断 / 堆栈八股精讲

适用人群：和我一样正在准备 2026 秋招的嵌入式方向同学------基础学过、外设调过几遍，但一被面试官追问"为什么"就嘴卡

读完你能得到：① 知道这些"反反复复被问"的八股到底在筛什么人；② 怎么答才不像背书、怎么露出"我踩过坑"的味儿；③ 把前几期已经讲过的东西串成一条面试答线，不再是散点

这一篇是 "面试高频考点" 专栏的第 1 篇，也是整个体系的"收口复习"------前面 C 语言、核心概念、调试排错那些专栏把技术点都讲透了，本栏换"面试视角"再过一遍：不只讲技术，更讲怎么答得让面试官觉得你是真懂。

一、为什么这些"八股"反反复复被问

我准备秋招这段时间，把网上能搜到的嵌入式面经翻了个遍。结论很朴素：翻来覆去就是 volatile、中断、堆栈、大小端、对齐这几样 。一开始我也觉得"这有什么好问的，不就背一下嘛"，直到自己模拟面试被怼了三次才反应过来------面试官不是在考你背书，是在用这些问题用 30 秒判断你是"背了"还是"懂了"。

举个例子。"volatile 有什么用"------

背书答法："防止编译器优化。"（5 个字，到此为止）
懂了的答法："防止编译器把对这个变量的读优化掉。具体到三个场景：ISR 和主循环共享的标志位、内存映射的硬件寄存器、MMU 改的页表项。但要补一句------它不保证原子性 ，多任务共享还是要关中断或用 __atomic 内建函数。"

后面这个答案，面试官立刻知道：① 你写过中断；② 你被 -O2 坑过；③ 你知道 volatile 的边界在哪。前一个答案，面试官只会觉得"又一个背了博客来的"。

所以本篇的写法是：把前面已经发过的相关文章（C语言_01_volatile、核心概念_01_中断、核心概念_03_启动流程、调试排错_03_栈溢出、C语言_02_对齐、C语言_05_大小端）里讲透的技术点，重新组织成"面试答法"------技术细节我不重复全文，只点一句"详见 XXX"，重点放在"为什么这么问、坑在哪、怎么答得不像背书"。

⚠️ 这一篇默认你已经看过前面那几篇。如果某个点你完全没接触过，先去对应专栏补一下再回来，效果会好很多。本篇的价值在于"串"，不在于"重新讲一遍"。

二、volatile（呼应 C语言_01）

技术原理详见 C语言嵌入式精讲/C语言_01_volatile关键字详解.md，这里只讲面试视角。

2.1 面试官到底想听到什么

volatile 的三个作用，背一个不算懂，三个都能说出来 + 知道边界，才算懂：

#	作用	一句话答法
1	防编译器优化掉读	"告诉编译器这个变量随时可能被程序之外的因素改变，每次用都要从内存重新读，别缓存到寄存器。"
2	防编译器对这个变量的访问做某些重排	C 标准（C11 6.7.3）只保证 volatile 访问确实发生且按代码顺序相对其他 volatile 访问，不保证它和非 volatile 操作的整体顺序------所以它不是内存屏障。
3	硬件寄存器 / MMU / ISR 共享变量	三个典型场景：外设寄存器映射、ISR 改主循环读的标志、RTOS 任务间简单标志位。

第 2 条是新手最容易答错的。很多人张口就来"volatile 防止指令重排"------这是错的。C 标准的原文精神是：volatile 访问是可观察的副作用（observable behavior），编译器不能把它优化没，也不能把两个 volatile 访问互相重排；但 volatile 访问和非 volatile 操作之间，编译器在某些架构下仍可能重排。所以 volatile 不能当内存屏障用，更不能当锁用。

2.2 最高频的"陷阱题"：volatile 能不能保证线程安全

不能。 这题面试官就是想听这一句，然后听你解释为什么。

答法（建议背下来这个逻辑链，不是背句子）：

volatile 只管"每次都从内存读"，不管读-改-写是不是原子的。
比如 volatile uint32_t counter; counter++; 在 32 位 MCU 上展开是"读 counter → 加 1 → 写回"三条指令，中间能被中断打断，读到半新半旧的值。
更要命的是 8/16 位 MCU 上，连单次读 32 位变量都不是原子的（要分两条指令）。
所以多任务/中断共享的"读-改-写"，要么关中断 （裸机 __disable_irq() / FreeRTOS taskENTER_CRITICAL()），要么用 C11 <stdatomic.h> 的 atomic_fetch_add，要么用 CMSIS 的 __atomic_* 内建函数，要么用 RTOS 的队列/信号量。

⚠️ 我模拟面试的时候被追问过一句："那 __NOP() 能不能保证原子性？"------不能。__NOP() 只是一条空指令，编译器不会跨过它优化，但它不关中断、不加锁，跟原子性半毛钱关系都没有。它的用途是"占一个时钟周期"或"对齐流水线"，被问到的同学别答错。

2.3 const volatile 同时存在------经典送分题

"const 和 volatile 能同时用吗？"------能，而且非常常见。

c 复制代码

/* 只读的硬件状态寄存器：程序不能写（const），但每次都要从硬件读最新值（volatile） */
const volatile uint32_t *chip_id = (uint32_t *)0x1FFFF7E8;
uint32_t id = *chip_id;  /* 读芯片唯一 ID */

const：程序代码不能通过这个指针写它（编译期检查）。
volatile：每次读都要真的去硬件读，别缓存。
两者不矛盾------const 管的是"程序员"，volatile 管的是"编译器对硬件的态度"。

另一个常见场景：只读的 ADC 数据寄存器。程序只读不写（const），但硬件每个采样周期都会更新它（volatile）。

2.4 面试加分答法

被问"volatile 有什么用"时，把这三句按顺序甩出来，基本稳了：

三个作用（防优化掉读 / 防 volatile 间的某些重排 / 三个场景）。
主动补一句边界："但它不保证原子性，也不能当内存屏障，多任务共享还是要关中断或用 atomic。"
主动举一个你简历项目里的例子："我做个气象节点，串口 ISR 收数据置标志位，主循环读标志位，那个标志位就必须 volatile------我一开始没加，开了 -O2 主循环就死等，加完就好。"

第 3 步是关键。没有项目例子，前面两条就是背书；有了项目例子，面试官立刻信你是真做过。 如果你简历上没有合适的项目，去 项目实战 里挑一个我写过的，把它变成"你的"。

三、中断相关八股（呼应核心概念_01）

中断的完整原理见 嵌入式核心概念/核心概念_01_中断详解.md，这里只讲面试视角。

3.1 "ISR 应该尽量短"------面试官想听的不是这句话本身

谁都会说"中断要短"，但面试官追问"为什么短、多短算短、长了会怎样"，一半人就哑了。完整的答法是三层：

为什么短 ：ISR 执行时，同级和更低优先级的中断都被屏蔽（不是所有中断，是同级及更低）。ISR 越长，这些中断的延迟就越大，最坏情况会"饿死"------一直轮不到执行。
多短算短 ：没有绝对数字，但经验值是"几十微秒内完成"。一个实用的自检标准：ISR 里不出现任何函数调用最好，非调不可就调一个"清标志 + 存数据 + 发通知"的极简函数。
长了会怎样 ：① 别的中断延迟飙升；② 如果你 ISR 里调了 HAL_Delay / vTaskDelay，直接死锁 ------因为 HAL_Delay 依赖 SysTick 中断进中断加 tick，而你现在就在中断里、SysTick 进不来；③ 如果你 ISR 里用了不带 FromISR 的 RTOS API，configASSERT 会断言失败，或者更阴间------内核链表被悄悄破坏，几分钟后随机死机。

3.2 ISR 里的"四不"------必背

❌ 不能做	为什么	✅ 替代方案
不能 `HAL_Delay` / `vTaskDelay`	中断里不能阻塞，`HAL_Delay` 靠 SysTick 进中断，进不来就死锁	用定时器或软定时器标志位，主循环/任务里等
不能 `printf`	`printf` 可能吃几百字节栈 + 几百微秒，ISR 里是大忌	存到缓冲区，主循环里打；或用 ITM/SWO 这种硬件 trace
不能 `malloc` / `free`	堆分配不是中断安全的，且耗时不可控	初始化时静态分配，或用 FreeRTOS 内存池
不能用不带 `FromISR` 的 RTOS API	FreeRTOS 规定 ISR 里只能用 `FromISR` 版，否则崩	`xQueueSendFromISR`、`vTaskNotifyGiveFromISR` 等

3.3 `__disable_irq` / 临界区嵌套------常被追问的细节

裸机里保护共享变量最朴素的做法是关中断：

c 复制代码

__disable_irq();
shared_counter++;   /* 这段不会被任何中断打断 */
__enable_irq();

但直接用 __enable_irq 有个坑 ：如果这段代码是被已经关过中断的上层 调用的，你 __enable_irq 一开，就把上层关的中断也开了，破坏了上层的临界区。

正确做法是保存-恢复：

c 复制代码

uint32_t primask = __get_PRIMASK();   /* 读当前中断状态 */
__disable_irq();
shared_counter++;
__set_PRIMASK(primask);               /* 恢复成进入前的状态 */

FreeRTOS 的 taskENTER_CRITICAL() / taskEXIT_CRITICAL() 内部就是这么做的------支持嵌套，所以你在任务里可以放心地"临界区套临界区"，不会因为内层退出把外层的中断打开了。这是面试常问的"临界区为什么能嵌套"的答案。

⚠️ 临界区三条铁律：① 尽可能短 ------关中断期间所有中断都进不来，影响实时性；② 不能阻塞 ------里面不能调任何可能阻塞的 API；③ 不能 printf------理由同 ISR。

3.4 volatile 标志位 + 主循环轮询：最朴素的中断-主循环协作模式

这是裸机里最常见、面试也最常让你"写一段"的模式：

c 复制代码

/* 平台：STM32 裸机，串口收数据，主循环处理 */
volatile uint8_t  rx_ready = 0;   /* ISR 写、main 读 → 必须 volatile */
volatile uint8_t  rx_data;

void USART1_IRQHandler(void)
{
    if (USART1->SR & USART_SR_RXNE) {
        rx_data = USART1->DR;     /* 读 DR 自动清 RXNE */
        rx_ready = 1;
    }
}

int main(void)
{
    /* ... 初始化 ... */
    for (;;) {
        if (rx_ready) {
            process_byte(rx_data);
            rx_ready = 0;
        }
        /* 其他工作 */
    }
}

面试官爱追问的几个点：

为什么 rx_ready 必须 volatile？ ------主循环 for 里 if (rx_ready) 不加 volatile，-O2 会把"读 rx_ready"优化成只读一次缓存到寄存器，永远进不去 if。
rx_ready = 0 这行会不会和 ISR 冲突？ ------这里 rx_ready 是 uint8_t，单字节读写在 32 位 MCU 上是原子的，所以这里不需要关中断 。但如果是 uint32_t 在 8 位 MCU 上，或要做"读-改-写"（比如 counter++），就必须关中断。这是判断你是不是真懂原子性的关键题。
这个模式有什么缺点？ ------主循环在干别的活时，rx_ready 可能在下一个字节来了之后还没被处理，新字节覆盖旧字节。所以实际项目里要么用环形缓冲区，要么上 RTOS 用队列。主动说出缺点 = 加分。

3.5 中断嵌套与优先级------别把数字方向记反

一句话：数字越小，优先级越高。优先级 0 是最高的。

嵌套规则只有一条：只有抢占优先级更高的中断，才能打断当前正在执行的中断。同级不能嵌套，后触发的排队等（pending）。

text 复制代码

主程序运行中
   ↓
UART1(抢占3) 触发，进 ISR
   ↓
TIM2(抢占1) 触发 → 打断 UART1，进 TIM2 ISR（嵌套）
   ↓
TIM2 执行完，回 UART1 ISR
   ↓
UART1 执行完，回主程序

推荐用 NVIC_PRIORITYGROUP_4：4 位全给抢占优先级，16 级，没有子优先级，概念最简单。这也是 HAL 库 HAL_NVIC_SetPriorityGrouping 的推荐值。

四、堆栈八股（呼应核心概念_03 / 调试排错_03）

启动流程里的栈见 嵌入式核心概念/核心概念_03_启动流程详解.md；栈溢出定位见 11_调试与排错/调试排错_03_栈溢出与内存踩踏定位.md。这里讲面试视角。

4.1 栈和堆的区别------表格必背

对比项	栈（Stack）	堆（Heap）
生长方向	Cortex-M 上向下生长（高地址→低地址）	一般向上生长（低地址→高地址）
谁管理	编译器自动分配/回收（函数进出栈）	程序员手动 `malloc`/`free`
生命周期	函数返回即回收	`free` 之前一直在
速度	快（一条 `PUSH`/`POP` 指令）	慢（要遍历空闲链表）
碎片	无（LIFO，自动整理）	有（反复 malloc/free 不同大小会切碎）
大小	启动文件 `Stack_Size` 固定	`configTOTAL_HEAP_SIZE` 或链接脚本 `_Min_Heap_Size`
安全性	溢出会踩踏别的内容，无运行期保护（裸机）	忘 free 泄漏，悬空指针踩踏

4.2 栈里都装什么------这条面试爱问

按压栈顺序：

局部变量 （函数里 int a; 这类）
函数参数（Cortex-M AAPCS 约定：前 4 个参数走 R0-R3 寄存器，超出的压栈）
返回地址 （LR，BL 调用时硬件自动保存到 R14，需要嵌套调用时再压栈）
被调用者保存的寄存器（R4-R11，AAPCS 规定这些寄存器由被调用函数负责保存）
中断现场（Cortex-M 进中断时硬件自动压 8 个寄存器：xPSR, PC, LR, R12, R3-R0；开了 FPU 再压 16 个浮点寄存器）

⚠️ 第 5 条很关键------中断现场压在"被打断的那个栈"上 。在 FreeRTOS 的 Cortex-M port 里，任务跑在 PSP 上，所以中断现场压在任务自己的 PSP 栈 里，不是 MSP。这意味着：任务栈不仅要够任务自己用，还要留出中断嵌套压栈的余量 。这条是新手最容易忽略的，也是 调试排错_03 里坑 8 讲的。

4.3 栈溢出怎么定位------把调试排错_03 的链子答出来

面试官问"你的程序偶发死机，怀疑栈溢出，怎么查"，别只说"调大栈试试" 。正确答法是把整条定位链说出来（这条链就是我 调试排错_03 的全文主线）：

text 复制代码

怀疑栈溢出
   │
   ├─ FreeRTOS 环境：
   │    1. 开 configCHECK_FOR_STACK_OVERFLOW=2（方法1看指针+方法2看栈末16字节指纹）
   │    2. 实现 vApplicationStackOverflowHook 钩子，在里面 bkpt 或存日志
   │    3. 用 uxTaskGetStackHighWaterMark() 定期打印各任务"历史最低水位"
   │       （注意返回单位是"字"不是字节，乘 sizeof(StackType_t)）
   │
   ├─ 裸机环境：
   │    1. 看 .map 算可用栈 = _estack - (.bss末尾 + heap用量)
   │    2. 自己糊栈涂色：开机把栈空闲区涂 0xA5A5A5A5，跑一段后看剩多少没动
   │    3. GCC -fstack-usage / Keil --callgraph 看每函数静态栈用量（递归和函数指针算不出）
   │
   └─ 都不灵（栈没溢出，是内存踩踏）：
        1. struct + canary 哨兵确认"确实有人踩"
        2. .map 看邻居缩小嫌疑人
        3. DWT watchpoint（M3/M4/M7）或 esp_cpu_set_watchpoint（ESP32）抓写入瞬间
        4. 现场没人 → DebugMon 记 PC / ESP32 core dump

能把这条链说清楚，面试官就知道你是真踩过坑、真用过工具，而不是背了"调大栈"三个字。

⚠️ configCHECK_FOR_STACK_OVERFLOW 的 1 和 2 区别也是高频追问：方法 1 看切换瞬间的栈指针，方法 2 还看栈末 16 字节的 0xa5a5a5a5 指纹有没有被改。方法 2 抓得住"任务中间戳到界外又缩回来"，方法 1 抓不住。开发阶段无脑用 2。

4.4 Cortex-M 的双栈 MSP/PSP------呼应核心概念_03

这是中高级岗位的筛选题，能答出来直接加分。

Cortex-M3/M4/M7 有两个物理栈指针 ，公用同一个 R13 寄存器名，由 CONTROL 寄存器 bit1 选择：

模式	用哪个栈	谁在这模式
Handler 模式（中断里）	永远 MSP	所有 ISR、异常处理函数
Thread 模式（普通代码）	`CONTROL[1]=0` 用 MSP；`CONTROL[1]=1` 用 PSP	复位后默认 MSP；RTOS 启动后任务切到 PSP

启动时硬件从 Flash 起始地址（0x08000000）读第一个字加载到 MSP ------所以启动文件里 Stack_Size 配的就是 MSP 的大小。

裸机：全程用 MSP，中断和主程序共用一个栈。

FreeRTOS（Cortex-M port） ：vTaskStartScheduler 启动第一个任务时，通过 SVC 触发的 vPortSVCHandler 会把 CONTROL[1]（SPSEL）置 1，任务跑在 PSP 上；此后中断发生时硬件自动切回 MSP 压现场。所以：

任务栈 = PSP，每个任务独立一块（xTaskCreate 时的 usStackDepth 参数）。
中断栈 = MSP，就是启动文件里 Stack_Size 那块，所有中断共用。

⚠️ 这就是为什么 调试排错_03 里那个坑 8 特别阴间：很多人以为上了 FreeRTOS，启动文件的 Stack_Size 就没用了 ------错。中断还是跑在 MSP 上，Stack_Size 必须留够中断嵌套深度，否则中断里栈溢出，没有任何钩子会告诉你（FreeRTOS 的栈检查只查任务栈，不查 MSP）。

4.5 AAPCS 栈对齐------常被顺手问

ARM AAPCS（Procedure Call Standard for the ARM Architecture）规定：函数调用边界处，SP 必须 8 字节对齐 。也就是说 (uint32_t)SP % 8 == 0。

为什么？因为很多指令（比如 LDM/STM 多寄存器加载、VLDM 浮点加载）要求 8 字节对齐才高效，不对齐要么慢要么触发未对齐访问异常。Cortex-M3/M4 的硬件进中断时会自动把 SP 对齐到 8 字节 再压栈（压 32 字节异常帧），所以你不主动管也一般没事------但如果你在裸机里手写汇编或混合调用，破坏了 8 字节对齐，调用 sprintf("%f") 这类严格遵守 AAPCS 的函数就可能崩。Keil 里那个 PRESERVE8 指令就是告诉汇编器"我保证 8 字节对齐"用的。

五、大小端与对齐（呼应 C语言_02/05）

完整原理见 C语言嵌入式精讲/C语言_02_struct内存对齐详解.md 和 C语言_05_大端小端详解.md。这里讲面试视角。

5.1 怎么测大小端------两种写法都要会

方法 1：union 法（最常考）

c 复制代码

#include <stdint.h>

int check_endian_union(void)
{
    union {
        uint16_t val;
        uint8_t  bytes[2];
    } t;

    t.val = 0x0102;
    /* bytes[0] 是低地址那个字节 */
    return (t.bytes[0] == 0x02) ? 1 : 0;  /* 1=小端, 0=大端 */
}

方法 2：指针强转法

c 复制代码

#include <stdint.h>

int check_endian_ptr(void)
{
    uint32_t x = 0x12345678;
    uint8_t *p = (uint8_t *)&x;
    /* *p 是低地址那个字节 */
    return (*p == 0x78) ? 1 : 0;  /* 1=小端, 0=大端 */
}

两种都对的。union 法更"正规"一点（C 标准允许 union 这种类型双关），指针强转法严格说是 implementation-defined，但在所有主流编译器上都work。面试写哪个都行，能说出"两种都行，union 更标准"是加分。

记忆口诀：大端 = 大字节在前（低地址）；小端 = 小字节在前（低地址） 。STM32（Cortex-M）默认小端，x86 也是小端，网络字节序（TCP/IP）是大端。

5.2 网络字节序------为什么是大端

历史原因：1980 年代互联网设计时，主机字节序五花八门，TCP/IP 规定统一用大端作"网络字节序"，发数据前转大端，收到后转回本机序。

Linux/Windows 上用 htonl/htons/ntohl/ntohs（host ↔ network，l=32位，s=16位）。STM32 上没有 <arpa/inet.h>，要自己实现：

c 复制代码

#include <stdint.h>

uint16_t swap16(uint16_t v) { return (v >> 8) | (v << 8); }

uint32_t swap32(uint32_t v)
{
    return ((v >> 24) & 0x000000FF) |
           ((v >> 8)  & 0x0000FF00) |
           ((v << 8)  & 0x00FF0000) |
           ((v << 24) & 0xFF000000);
}

/* STM32 小端，发网络包前转大端 */
#define htons(x) swap16(x)
#define htonl(x) swap32(x)
#define ntohs(x) swap16(x)
#define ntohl(x) swap32(x)

ARM 有专用指令 __REV（32 位反转）/ __REV16（16 位反转），比 C 实现快，CMSIS 里直接能用。

关键认知 ：只有多字节整数 （uint16_t/uint32_t/float）才有字节序问题。uint8_t 数组、字符串没有字节序问题------逐字节存逐字节发，大端小端都一样。这条面试爱问。

5.3 对齐规则三条------必背

成员偏移 ：每个成员的偏移量必须是 min(成员大小, 默认对齐数) 的整数倍。
总大小 ：结构体总大小必须是 最大成员大小 的整数倍。
嵌套：嵌套结构体按其自身最大成员大小对齐。

例：

c 复制代码

struct A {
    char  a;   /* 偏移0，1字节 */
    /* pad 3 字节 */
    int   b;   /* 偏移4，4字节 */
    short c;   /* 偏移8，2字节 */
    /* pad 2 字节，总大小对齐4 → 12 */
};
/* sizeof = 12，不是 7 */

省空间的技巧：成员从大到小排列，能减少 padding。

5.4 取消对齐：`#pragma pack` / `attribute((packed))` ------和它的代价

通信协议帧是紧凑排列的（无 padding），用结构体直接映射必须取消对齐：

c 复制代码

/* 方法 1：pragma pack */
#pragma pack(push, 1)
typedef struct {
    uint8_t  header;     /* 1 */
    uint16_t length;     /* 2 */
    uint32_t data;       /* 4 */
} frame_t;               /* sizeof = 7，紧凑 */
#pragma pack(pop)

/* 方法 2：GCC/Keil 的 attribute */
struct __attribute__((packed)) frame2 {
    uint8_t  header;
    uint16_t length;
    uint32_t data;
};                       /* sizeof = 7 */

代价（面试必问）：

代价	说明
访问变慢	非对齐的 `int` 访问，CPU 可能要读两次再拼接（M3/M4 有硬件支持但慢；M0/M0+ 直接 HardFault）
M0 上直接崩	Cortex-M0 不支持非对齐访问，packed 后访问非对齐的 32 位成员 → UsageFault / HardFault
不能直接给 DMA	DMA 通常要求对齐访问，packed 结构体要先 memcpy 到对齐缓冲区

⚠️ Cortex-M0/M0+ 这个坑要单独记 ：M0 为了省硅面积去掉了非对齐访问硬件，packed 结构体里 frame->data 这种访问直接 HardFault。M3/M4/M7 有硬件支持，只是慢。所以"packed 能不能用"答案是"看内核"，M0 上 packed + 直接访问 = 崩。M0 上的安全做法 ：用 memcpy 取出非对齐成员到对齐变量再操作。

c 复制代码

/* M0 上安全访问 packed 成员 */
uint32_t val;
memcpy(&val, &frame->data, sizeof(uint32_t));  /* memcpy 按字节拷，不做非对齐访问 */
/* 之后用 val */

六、新手必踩的 N 个坑

这一栏是我准备秋招时把前几篇文章里踩过的坑重新筛了一遍，留下面试官最爱追问、新手最常翻车的几条。每一条都对应前面某一篇的详细分析，这里给"面试一句话版"。

#	坑	后果	正确做法	详见
1	volatile 当锁用	以为加了 volatile 就线程安全，多任务 `counter++` 读到半新半旧值	volatile 只防优化不防并发；读-改-写要关中断或用 `__atomic` / `stdatomic.h`	C语言_01 §5
2	ISR 里 printf 死锁	printf 吃几百字节栈 + 几百微秒，ISR 里直接崩或拖死其他中断	ISR 只清标志+存数据+发通知；打印甩给主循环或任务；调试用 ITM/SWO	核心概念_01 §5
3	栈设太小（启动文件 `Stack_Size` 或任务栈）	函数调用层级深 / 大局部数组 → 栈溢出踩踏，偶发死机	启动文件栈 1KB 起步；任务栈先按 512 字给，跑够久用 `uxTaskGetStackHighWaterMark` 调；大数组改 `static`	调试排错_03 §3
4	忘关中断改共享变量	主循环 `counter++` 被 ISR 打断，读到中间态	临界区 `__disable_irq`/`taskENTER_CRITICAL` 包住读-改-写；或用 `stdatomic.h`	核心概念_01 §6
5	对齐强转在 M0 上 HardFault	`(uint32_t)` 强转非对齐地址，M0 直接崩（M3/M4 慢但不崩）	M0 上用 `memcpy` 取出非对齐成员；packed 结构体尤其注意	C语言_02 §6
6	`__enable_irq` 破坏嵌套临界区	内层 `__enable_irq` 把外层关的中断也开了	用 `__get_PRIMASK`/`__set_PRIMASK` 保存-恢复，或用 `taskENTER/EXIT_CRITICAL`（已支持嵌套）	核心概念_01 §6
7	上了 FreeRTOS 就以为启动文件 `Stack_Size` 没用	中断跑在 MSP 上，中断嵌套深了 MSP 溢出，没有任何钩子告诉你	启动文件 `Stack_Size` 仍要留够中断嵌套余量；任务栈要额外留出中断现场压栈的 8/32 字节	调试排错_03 坑8
8	以为 volatile 防止指令重排	拿 volatile 当内存屏障，多线程时序还是错	volatile 只保证 volatile 间的相对顺序；要屏障用 `DMB`/`__DMB()` 或 `stdatomic.h` 的 memory_order	C语言_01 §5
9	`sizeof(指针)` 当 `sizeof(数组)` 用	`memcpy(dst, src, sizeof(src))` 里 src 是指针时恒为 4，少拷或越界	长度显式传参；数组退化成指针后 sizeof 就废了	调试排错_03 §5

💡 这张表不是用来背的，是用来"对号入座"的------秋招前你过一遍，每一条都对照自己简历上的项目，问自己"我能不能讲出一个我踩过这个坑的具体场景"。能讲出来 3 条以上，面试基本稳了。

七、动手练一练

光看不练，面试时还是嘴卡。下面这几步建议你用开发板真跑一遍（别用正在用的项目板，故意搞破坏用）。

练习 1：故意不 volatile，看 -O2 怎么优化掉读

c 复制代码

/* 平台：STM32 + Keil/GCC，开 -O2 优化 */
#include <stdint.h>

uint8_t flag = 0;   /* 故意不加 volatile */

void wait_flag(void)
{
    while (flag == 0) {   /* -O2 下会被优化成 while(1) */
        /* 等 */
    }
}

/* 在另一个文件的中断里改 flag，或者用调试器手动改 flag 的内存值 */

步骤：

先用 -O0 编译，跑起来，用调试器把 flag 改成 1，看 wait_flag 能不能跳出。能跳出。
切 -O2，同样操作，看能不能跳出。跳不出 ------因为 flag 被缓存到寄存器了，内存里改了它读不到。
加上 volatile，再 -O2，再试。跳出。
加分：把汇编反汇编打开（Keil 看 .s，GCC 用 objdump -d），对比 -O0 和 -O2 下 wait_flag 的汇编，亲眼看见 while(flag==0) 变成 b .（死循环）。

这个练习做一遍，面试官问"volatile 为什么必要"，你能直接说"我用调试器亲眼看过 -O2 把 while 优化成死循环"------这比任何博客都有说服力。

练习 2：故意在 ISR 里 printf，看死锁/栈爆

c 复制代码

/* 平台：STM32 裸机或 FreeRTOS */
void USART1_IRQHandler(void)
{
    if (USART1->SR & USART_SR_RXNE) {
        uint8_t d = USART1->DR;
        printf("got 0x%02X\r\n", d);   /* 故意作死 */
    }
}

步骤：

跑起来，多发几个字节，观察现象：要么完全没输出（printf 自己吃栈爆了），要么输出几个就死，要么其他中断全延迟飙升。
用 uxTaskGetStackHighWaterMark（FreeRTOS）或栈涂色（裸机）量一下 printf 进 ISR 前后的栈用量差------你会被吓到。
改成"ISR 存数据 + 置 flag，主循环里 printf"，再跑，对比。

做完这个，面试问"ISR 里为什么不能 printf"，你能说"我量过，printf 进 ISR 直接吃掉几百字节栈"------又是真数据。

练习 3：故意 packed + 非对齐访问，看 M0/M3 差异

c 复制代码

#pragma pack(push, 1)
typedef struct {
    uint8_t  cmd;       /* 偏移 0 */
    uint32_t data;      /* 偏移 1 ------ 非对齐！ */
} pkt_t;
#pragma pack(pop)

pkt_t pkt = {0xAA, 0x12345678};

void test(void)
{
    /* 直接访问非对齐的 data */
    uint32_t v = pkt.data;   /* M0 上 HardFault，M3/M4 上慢但能跑 */
}

步骤：

在 Cortex-M3/M4（STM32F4）上跑，能跑，但用 DWT 周期计数器量一下 pkt.data 的访问周期，对比对齐的访问------非对齐慢一截。
如果有 Cortex-M0 的板子（比如 STM32F0/G0），同样代码跑一下，直接 HardFault。
改成 memcpy(&v, &pkt.data, 4)，两种内核都能跑。

做完这个，"M0 不支持非对齐访问"就不再是博客上的话，是你亲手验证过的事实。

练习 4：测一下你板子的大小端

c 复制代码

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    uint32_t x = 0x12345678;
    uint8_t *p = (uint8_t *)&x;
    printf("byte[0]=0x%02X\n", p[0]);
    /* STM32 上输出 0x78 → 小端 */
}

STM32 输出 0x78，证实小端。再写个 swap32 把它转成大端，用调试器看内存布局，理解"网络字节序"为什么需要转换。这个 5 分钟搞定，但能让你彻底不再混淆大小端。

八、小结：秋招前怎么用这一篇

这一篇不是"新知识"，是收口复习。秋招前我用它的方式是：

每一条都对照简历上我写过的项目，想一个"我能怎么答"。 比如面试官问"volatile"，我不只答三个作用，还会说"我气象节点项目里串口 ISR 收数据置标志位，那个标志位就加了 volatile，不然 -O2 主循环死等"------把简历项目和八股绑死，面试官就知道你是真做过。
把第六章那张踩坑表当 checklist。 每条问自己"我踩过没？能讲出具体场景吗？"------能讲出 3 条以上，这块面试基本稳了；讲不出，说明这块你还没真动手，赶紧补。
动手练习至少做完练习 1 和 2。 那两个练习做完，你面试时说"我用调试器亲眼看过 -O2 把 while 优化成死循环"、"我量过 printf 进 ISR 吃多少栈"------这种话一出口，面试官就知道你不是背书的。

最后送一句我自己最深的体会：八股本身不难，难的是把"背的"变成"踩过的"。 同样一句"volatile 防止编译器优化"，背出来和讲出来是两个味儿，面试官一听就知道。区别就在于你有没有真动手踩过那个坑。前面那 50 多篇文章我都写过、踩过，这一篇就是把它们拧成一根面试答线，希望对你秋招有用。

文中的 C 标准和 ARM 架构细节都对照了 C11 规范、AAPCS 和 ARMv7-M 手册，面试时把"为什么"讲清楚比背条款有用。

下一篇：面试_02_看门狗启动模式复位与Bootloader面试要点

面试高频考点 01：volatile / 中断 / 堆栈 八股精讲

一、为什么这些"八股"反反复复被问

二、volatile（呼应 C语言_01）

2.1 面试官到底想听到什么

2.2 最高频的"陷阱题"：volatile 能不能保证线程安全

2.3 const volatile 同时存在------经典送分题

2.4 面试加分答法

三、中断相关八股（呼应 核心概念_01）

3.1 "ISR 应该尽量短"------面试官想听的不是这句话本身

3.2 ISR 里的"四不"------必背

3.3 __disable_irq / 临界区嵌套------常被追问的细节

3.4 volatile 标志位 + 主循环轮询：最朴素的中断-主循环协作模式

3.5 中断嵌套与优先级------别把数字方向记反

四、堆栈八股（呼应 核心概念_03 / 调试排错_03）

4.1 栈和堆的区别------表格必背

4.2 栈里都装什么------这条面试爱问

4.3 栈溢出怎么定位------把调试排错_03 的链子答出来

4.4 Cortex-M 的双栈 MSP/PSP------呼应 核心概念_03

4.5 AAPCS 栈对齐------常被顺手问

五、大小端与对齐（呼应 C语言_02/05）

5.1 怎么测大小端------两种写法都要会

5.2 网络字节序------为什么是大端

5.3 对齐规则三条------必背

5.4 取消对齐：#pragma pack / __attribute__((packed)) ------和它的代价

六、新手必踩的 N 个坑

七、动手练一练

练习 1：故意不 volatile，看 -O2 怎么优化掉读

练习 2：故意在 ISR 里 printf，看死锁/栈爆

练习 3：故意 packed + 非对齐访问，看 M0/M3 差异

练习 4：测一下你板子的大小端

八、小结：秋招前怎么用这一篇

面试高频考点 01：volatile / 中断 / 堆栈八股精讲

三、中断相关八股（呼应核心概念_01）

3.3 `__disable_irq` / 临界区嵌套------常被追问的细节

四、堆栈八股（呼应核心概念_03 / 调试排错_03）

4.4 Cortex-M 的双栈 MSP/PSP------呼应核心概念_03

5.4 取消对齐：`#pragma pack` / `attribute((packed))` ------和它的代价