荣耀嵌入式一面连问中断:-O2 下死等、加了 volatile 照样丢数,我们实测了一遍
最近具身智能公司在抢嵌入式和控制方向的人。机器人关节的电机控制,常常是在每秒上万次的定时器或 ADC 中断里算一遍电流环。中断里多耗一点时间,或者共享变量丢一次更新,电机就可能抖一下。中断是嵌入式面试绕不开的一块,我们收录的 1426 场嵌入式面经里,三成问到了中断或 volatile。
这组题来自其中一场 2026 年荣耀嵌入式软件工程师一面。面试官从中断连着追了 3 问:
中断发生以后,程序怎么进入处理函数,又怎么回到原来的位置? → 中断处理函数里哪些事情不适合做?收到数据后怎么交给任务处理? → 中断和任务共用一个变量,volatile 能解决哪些问题,哪些解决不了?
最后一问是关键。网上常见的答法是“volatile 告诉编译器别优化,每次都从内存读”,这句没错,但只答了前半问,面试官问的是“哪些解决不了”。我们用 gcc 和 clang 把这几件事都跑了一遍。
先说结论
- 怎么回到原位置:Cortex-M 上,硬件进中断时自动保存 8 个寄存器,并在 LR 里放一个特殊值 EXC_RETURN;处理函数返回时 CPU 认出这个值,把寄存器恢复回去。Linux 的信号处理是同一个思路:我们实测,3 次中断打断在同一个函数的 3 个不同位置,处理函数的返回地址却都指向同一段专门恢复现场的代码。
- 中断里不能做什么:不能阻塞、不能耗时,也不能调用 malloc、printf 这类不可重入的函数。我们在“中断”里调 malloc,单线程时 glibc 不加锁,没有卡住;进程一变成多线程,3 次都在第 1 秒内死锁。MCU 上的后果取决于 malloc 怎么加锁,可能是死锁、触发断言,或者把堆写坏。
- volatile 能解决的:编译器把变量缓存在寄存器里、看不到中断的修改。不加 volatile,gcc -O2 编出的等待循环只读一次标志,然后原地死循环;clang 编 Cortex-M 的同一段代码,干脆把整个循环删了,函数直接返回。
- volatile 解决不了的:读、改、写的原子性。中断和任务都对同一个计数器加一,加了 volatile 照样会丢。我们这台服务器上丢了九成以上,另一台电脑的 WSL 里丢了约六成,具体比例看机器和测法。关中断或者用原子操作,都一次没丢。
怎么测的,以及这种测法的局限
我们手边没有开发板,用 Linux 的信号来模拟中断:定时器每隔一段时间发一个信号,信号处理函数就相当于 ISR(中断服务函数)。信号来的时候主程序执行到哪就停在哪,处理函数跑完再接着执行,这一点和中断很像。
环境是 gcc 13.3(x86-64,-O2),另外用 clang 18 把同样的 C 代码编成 Cortex-M3 汇编(--target=thumbv7m-none-eabi)。这种测法有几处和真 MCU 不一样,先说清楚:
- Cortex-M 部分只看了汇编,没有上板。 进出中断的硬件过程来自 ARMv7-M 架构手册,不是我们测出来的。
- 信号没有中断优先级、嵌套和尾链。 处理函数执行期间,同一个信号被屏蔽,相当于所有中断同一个优先级;延迟也是微秒级、不稳定的。
- 丢失比例被测法放大了。 我们的任务除了加一什么都不做,中断几乎每次都落在“读完还没写”的窗口里。真实程序里是偶尔丢一次,反而更难查。
- malloc 死锁是 glibc 的表现,MCU 上后果不一样,第 2 节会说。
volatile 那两节受影响最小:编译器怎么优化、读改写怎么被打断,在哪种架构上道理都一样。
逐条实测
1. 中断怎么进去,又怎么回来
在 Cortex-M 上:
- 中断到来时,硬件自动把 8 个寄存器压栈:R0~R3、R12、LR、PC、xPSR(程序状态寄存器)。压进去的 PC 是返回后要接着执行的那条指令。芯片带 FPU 并且用到了浮点时,还会多存 S0~S15 和 FPSCR,这叫扩展栈帧。
- 硬件从中断向量表里取出处理函数的地址,跳过去执行,同时往 LR 里写一个特殊值 EXC_RETURN。裸机常见 0xFFFFFFF9(返回线程模式、用主栈 MSP);跑 FreeRTOS 时任务用进程栈 PSP,是 0xFFFFFFFD;中断嵌套时返回到上一层中断,是 0xFFFFFFF1。
- 处理函数结束时,把 LR 里的值装回 PC(
bx lr,或者函数里调了别的函数时是pop {..., pc})。CPU 发现目标地址是 EXC_RETURN,就知道这是中断返回,把栈上的寄存器弹回去,程序回到被打断的地方。
为什么中断处理函数能写成普通 C 函数?因为硬件保存的那 8 个,正好是 ARM 函数调用约定(AAPCS)里“由调用者负责保存”的寄存器。剩下的 R4~R11,编译器本来就会在函数开头按需压栈、结尾恢复。硬件和编译器各管一半,加起来就是完整的现场。这一点常被追问。
Linux 信号是同一个思路,只是现场由内核保存。我们让定时器每 20ms 打断一次一个忙循环 busy_task,在处理函数里记下两个地址:一个是内核传进来的被打断时的指令地址(从 ucontext 里取 RIP),一个是处理函数自己的返回地址(__builtin_return_address(0))。busy_task+0x37 的意思是 busy_task 函数开头往后第 0x37 字节处。
第 1 次中断:打断在 busy_task+0x37,处理函数返回到 0x7553d4445330
第 2 次中断:打断在 busy_task+0x34,处理函数返回到 0x7553d4445330
第 3 次中断:打断在 busy_task+0x25,处理函数返回到 0x7553d4445330
3 次打断的位置都不一样,中断可能落在任何一条指令上;返回地址却都一样。把那个地址的机器码反汇编出来:
mov $0xf,%rax
syscall
在 x86-64 Linux 上,15 号系统调用是 rt_sigreturn。处理函数返回后先到这里,再由内核把进入时保存的整套寄存器还原,主程序才从被打断的地方接着执行。这段代码的作用,相当于 Cortex-M 的 EXC_RETURN。
2. 中断里为什么不能调 malloc
常听到的说法是“中断里不能做耗时的事”。这是一条原因,但 malloc、printf 的问题主要不在快慢,而在于它们不可重入:一个函数执行到一半被打断,中断里又调用了它,两次调用会互相干扰,这样的函数就叫不可重入。
我们让任务一直 malloc、free,同时每 50 微秒来一次“中断”,中断里也调 malloc(4096) 和 free。先用单线程跑:
第 8 秒:任务 malloc 累计 217030656 次,中断里 malloc 累计 159945 次
8 秒没出事。原因是 glibc 发现进程只有一个线程,malloc 干脆不加锁。这不代表安全:没有锁,中断里的 malloc 打断了任务的 malloc,两边同时改堆的内部链表,堆可能被写坏,只是这次没撞上。
然后多开一个什么都不做的线程,进程变成多线程,glibc 的 malloc 就会加锁。连跑 3 次,每次都在第 1 秒内卡死,进程睡眠、CPU 占用为 0。用 gdb 看卡住时的调用栈,关键几行:
#2 __GI___libc_malloc (bytes=4096) ← 中断里的 malloc,在等堆的锁 main_arena
#3 isr_malloc (...)
#4 <signal handler called> ← 这里被打断
#7 __GI___libc_free (...) ← 任务正在 free,手里拿着这把锁
从下往上读:任务在 free 里拿着堆的锁,中断来了;中断里的 malloc 去等这把锁;锁要等任务释放,任务要等中断返回。谁也等不到谁,这就是死锁。
MCU 上的后果取决于 malloc 怎么加锁。嵌入式常用的 newlib,malloc 留了加锁的钩子:
- 裸机不加锁时,和上面单线程的情况一样,堆可能被写坏。
- 接 FreeRTOS 时,常见实现是挂起调度器,挡不住中断,结果还是可能写坏堆。
- 如果钩子里用的是互斥量,在中断里去拿,会触发 FreeRTOS 的断言。
总之都不能用。printf 更糟,它内部可能用到堆,还可能一直等着串口把字发完。
所以中断里只做三件事:清中断标志、把数据挪走、通知任务,耗时的处理留给任务。
收到数据怎么交给任务? 常用环形缓冲区,中断往里写,任务从里读(以 STM32F1/F4 的串口为例):
static volatile uint8_t buf[256];
static volatile uint8_t head, tail; // 下标用 uint8_t,加到 255 再加一自然回到 0,读写也是一条指令
// 只有中断写 head,只有任务写 tail
void USART1_IRQHandler(void) { // 中断:只负责把字节放进去
uint32_t sr = USART1->SR; // 先读状态寄存器,再读数据寄存器,顺带把溢出标志 ORE 也清掉
uint8_t c = USART1->DR; // 读 DR 同时清掉接收标志(F7/H7 等系列这个寄存器叫 RDR)
if (sr & USART_SR_RXNE) {
uint8_t next = head + 1;
if (next != tail) { buf[head] = c; head = next; } // 满了就丢,不能在中断里等
}
}
int uart_read(uint8_t *c) { // 任务:慢慢取
if (tail == head) return 0;
*c = buf[tail]; tail = tail + 1;
return 1;
}
head 只有中断写,tail 只有任务写,每个变量只有一个写者,下标的读写本身又是一条指令完成的,所以单核上不用加锁也是对的。buf 也加了 volatile,保证“先写数据、后改 head”的顺序不被编译器调换。
用了 FreeRTOS 的话,可以用 xQueueSendFromISR 发队列,或者用 vTaskNotifyGiveFromISR 叫醒处理任务。要注意两点:
- 必须用带 FromISR 后缀的版本,普通版本可能阻塞。调用这类函数的中断,优先级不能高于
configMAX_SYSCALL_INTERRUPT_PRIORITY,否则会触发断言,甚至把内核的数据结构搞乱。 - 传一个
xHigherPriorityTaskWoken进去,中断结束时调用portYIELD_FROM_ISR(xHigherPriorityTaskWoken)。如果被叫醒的任务优先级更高,中断一退出就切过去,不用等下一个时钟节拍。
3. volatile 解决了什么
经典场景:中断里置标志,任务里等它。
int flag; // 中断里会把它置 1
void on_alarm(int s) { flag = 1; }
...
while (!flag) { } // 任务在等
1 秒后定时器来一次“中断”,置 flag。4 种编法的结果:
gcc -O0 退出了等待循环
gcc -O2 卡死,4 秒后被 timeout 命令强制结束
gcc -O0 + volatile 退出了等待循环
gcc -O2 + volatile 退出了等待循环
只有开了优化又没加 volatile 的那个卡死了。看 gcc -O2 编出来的汇编:
cmpl $0, flag(%rip) ; 只读一次 flag
jne .L38 ; 是 1 就往下走
.L39:
jmp .L39 ; 否则原地死循环,再也不读 flag
编译器的推理是:循环里没有任何代码会改 flag,它就不会变,读一次就够了。它看不到“中断会改它”。加了 volatile,就是告诉编译器“这个变量可能被你看不到的东西改”,每次都得去内存里读。
严格按 C 标准,信号处理函数里写的标志应该声明成 volatile sig_atomic_t,这里为了和 MCU 的写法对照,用了 int。
再看 MCU。同样的代码用 clang 编成 Cortex-M3 汇编(省略了把变量地址装进 r0 的两条指令):
wait_plain: ; while (!rx_flag); 没加 volatile
bx lr ; 整个循环没了,直接返回
wait_txe_plain: ; while (!(USART1_SR & (1u << 7))); 寄存器没加 volatile
ldrb r0, [r0] ; 只读一次,而且从 32 位读变成了 8 位读
lsls r0, r0, #24
it mi
bxmi lr ; 已经置位就返回
.LBB2_1:
b .LBB2_1 ; 否则死循环
wait_txe_volatile: ; 加了 volatile
.LBB3_1:
ldr r1, [r0] ; 每圈都重新读寄存器,而且是完整的 32 位读
lsls r1, r1, #24
bpl .LBB3_1
bx lr
第一个最出乎意料:没加 volatile 的等待循环,clang 直接把它删了,函数一进去就返回,根本不等。C11 标准规定,一个循环如果条件不是常量,循环里又没有输入输出、没有 volatile 访问、没有原子操作,编译器可以假设它最终会结束。flag 在循环里不会变,clang 就当它“已经结束”了。这是“允许”,不是“一定”:同样的规则也适用于第二个函数,clang 却没删它。用 -std=c99 编,第一个函数也会变回“读一次加死循环”。
同一个错误,gcc 编出来是死等,clang 编出来是不等,换个编译器或者优化级别,症状就完全不同。
第二个函数是忘了给外设寄存器加 volatile:只读一次,没置位就永远卡住。而且编译器把 32 位读改成了 8 位读,有些外设寄存器对访问宽度有要求,这本身就可能出错。正因为如此,芯片厂商的头文件里,寄存器都定义成 volatile,比如 STM32 头文件里的 __IO 宏就是 volatile。
4. volatile 解决不了什么
中断和任务都对同一个计数器加一,最后看总数对不对。下表来自我们完整的测试程序(和文末给读者的精简版参数不同):任务加 3 亿次,同时尽量密集地来“中断”,每次中断也加一。“屏蔽中断”那组每次加一都要调两次系统调用,太慢,只加了 500 万次。
普通变量 中断加了 26169 次,丢了 26168 次
volatile 中断加了 27956 次,丢了 26219 次
屏蔽“中断” 中断加了 555212 次,丢了 0 次
原子加 中断加了 228384 次,丢了 0 次
每种跑了 2 次,结果相近,表里列一次。
普通变量几乎全丢。编译器只在循环开始前读一次 count,最后一次性写回“原值 + 3 亿”,中断在中间加的全被覆盖了。
volatile 好不到哪去,在这台服务器上 2 次分别丢了 94% 和 91%。看汇编就明白:
mov count(%rip),%eax ; 读
add $0x1,%eax ; 加
mov %eax,count(%rip) ; 写
volatile 只保证每次都真的读内存、写内存,不保证读、加、写这三步中间不被打断。中断恰好落在“读完还没写”的时候,它加的那一次就被任务的写回盖掉了。
Cortex-M 上也一样,clang 编出的 volatile 计数器加一是 ldr、adds、str 三条指令。ARM 是 load-store 架构,运算只能在寄存器里做,不能直接对内存加一,一定是读、改、写三步。
解法有两种:
- 临界区里关中断:只需要在任务这一侧关,因为单核上任务打断不了中断。MCU 上是
__disable_irq()/__enable_irq(),对应一条cpsid i指令,很便宜;更稳妥的写法是先保存 PRIMASK(控制中断总开关的寄存器),用完再恢复。FreeRTOS 的taskENTER_CRITICAL()在 Cortex-M3/M4 上用的是 BASEPRI,只屏蔽优先级低于某个阈值的中断。我们在 Linux 上用 sigprocmask 屏蔽信号来模拟,一次没丢,但每次要调两次系统调用,500 万次花了 6 秒,比单片机上关中断贵得多。 - 原子操作:x86 上编译成一条
lock addl,一次没丢。Cortex-M3/M4 用 LDREX/STREX 实现:LDREX 读值并“登记”这个地址,STREX 写回时检查登记还在不在。进出中断时硬件会清掉这个登记,所以中断插在两条指令之间,STREX 就会失败,代码重新来一遍。Cortex-M0 没有这两条指令,只能关中断。
还有两种 volatile 也管不了的情况:
- 变量比总线宽:32 位 MCU 上读写一个 64 位变量要两条指令,中断可能落在两次读之间,读到一半新、一半旧的值。常见的读法是连读两次,两次相同才用。
- 多核或 DMA:volatile 只管编译器,不管 CPU 乱序和缓存。DMA 缓冲区要做缓存维护,多核之间要加内存屏障(如
__DMB())。
一分钟答法
进中断时,Cortex-M 硬件把 R0~R3、R12、LR、PC、xPSR 压栈,LR 里放一个 EXC_RETURN 值;返回时 CPU 认出这个值,把寄存器弹回去。硬件存的正好是调用约定里调用者该存的那部分,R4~R11 由编译器保存,所以 ISR 能写成普通 C 函数。
中断里不能阻塞、不能耗时,也不能调 malloc、printf 这类不可重入的函数,否则可能死锁、触发断言或者写坏堆。中断里只清标志、把数据放进环形缓冲区或队列、通知任务,RTOS 下用 FromISR 版本的接口。
volatile 解决的是可见性:不加的话,-O2 下等标志的循环可能只读一次然后死循环。它解决不了原子性:count++ 是读、改、写三步,中断插在中间就会丢,要在任务侧关中断或者用原子操作。
被追问时可以再展开:FPU 的扩展栈帧、FreeRTOS 下 EXC_RETURN 是 0xFFFFFFFD、FromISR 的优先级上限和 portYIELD_FROM_ISR、LDREX/STREX 为什么能防住中断、64 位变量的撕裂读。
自己跑一遍
Linux 或 WSL 上,保存成 isr_demo.c:
// 用 Linux 信号模拟中断:on_tick 相当于定时器中断的 ISR,main 相当于被打断的任务。
// 编译:gcc -O2 isr_demo.c -o isr_demo
// 运行:./isr_demo flag 中断置标志、任务等标志(不加 volatile 会卡死,Ctrl+C 退出)
// ./isr_demo count 中断和任务对同一个计数器 +1,看丢了多少
// 加 -DUSE_VOLATILE 再编一次对比
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#ifdef USE_VOLATILE
#define V volatile
#else
#define V
#endif
V int flag;
V int count;
volatile long isr_n;
void on_flag(int sig) { flag = 1; }
void on_tick(int sig) { count++; isr_n++; }
int main(int argc, char **argv) {
if (argc > 1 && !strcmp(argv[1], "flag")) {
signal(SIGALRM, on_flag);
struct itimerval once = {{0, 0}, {1, 0}}; // {重复间隔, 首次延时},各是 {秒, 微秒}:1 秒后来一次
setitimer(ITIMER_REAL, &once, NULL);
while (!flag) { } // 任务在等中断置位
printf("等到了 flag\n");
} else {
signal(SIGALRM, on_tick);
struct itimerval it = {{0, 10}, {0, 10}}; // 每 10 微秒一次(实际受内核精度限制)
setitimer(ITIMER_REAL, &it, NULL);
long N = 300000000;
for (long i = 0; i < N; i++) {
count++;
__asm__ volatile(""); // 让循环真的跑起来、耗点时间,好让中断有机会插进来
}
struct itimerval off = {{0, 0}, {0, 0}};
setitimer(ITIMER_REAL, &off, NULL);
printf("任务加 %ld 次 + 中断加 %ld 次,应为 %ld,实际 %d,丢了 %ld 次\n",
N, isr_n, N + isr_n, count, N + isr_n - count);
}
return 0;
}
我们的结果:
$ gcc -O2 isr_demo.c -o d0 && ./d0 flag
(卡住不动)
$ ./d0 count
任务加 300000000 次 + 中断加 38920 次,应为 300038920,实际 300000002,丢了 38918 次
$ gcc -O2 -DUSE_VOLATILE isr_demo.c -o d1 && ./d1 flag
等到了 flag
$ ./d1 count
任务加 300000000 次 + 中断加 176185 次,应为 300176185,实际 300011410,丢了 164775 次
不加 volatile 时,gcc 把循环编成了“开头读一次 count,最后写回原值 + 3 亿”,所以中断加的几乎全丢。中断次数和丢失比例每台机器都不一样,我们在另一台电脑的 WSL 里跑,volatile 版丢了约六成。但“不加 volatile 卡死”和“加了 volatile 照样丢”应该都能稳定复现。想看汇编,可以加 -S 编译,或者用 objdump -d d0。
这道题有多常见
我们收录的 1426 场嵌入式面经里,问到中断的有 358 场(25%),问到 volatile 的有 203 场(14%),两者合计 434 场,占三成。
volatile 的完整答案卡在这里,“中断与主循环共享变量”这道题在这里。想按嵌入式岗的真实面经被连续追问,可以用启面做 AI 模拟面试(利益相关:启面是我们做的)。
测试环境:gcc 13.3.0、clang 18.1.3,Ubuntu 24.04,x86-64,8 核 Linux 服务器,测试于 2026-11-10。用 Linux 信号模拟中断,Cortex-M 部分只看了编译出的汇编,硬件进出中断的过程以 ARMv7-M 架构手册为准。面经来自公开分享的面试经历。
本文由作者创作并审核,人工智能(AI)辅助修改,部分表述由 AI 辅助生成。
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐


所有评论(0)