最近具身智能公司在抢嵌入式和控制方向的人。机器人关节的电机控制,常常是在每秒上万次的定时器或 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 上:

  1. 中断到来时,硬件自动把 8 个寄存器压栈:R0~R3、R12、LR、PC、xPSR(程序状态寄存器)。压进去的 PC 是返回后要接着执行的那条指令。芯片带 FPU 并且用到了浮点时,还会多存 S0~S15 和 FPSCR,这叫扩展栈帧。
  2. 硬件从中断向量表里取出处理函数的地址,跳过去执行,同时往 LR 里写一个特殊值 EXC_RETURN。裸机常见 0xFFFFFFF9(返回线程模式、用主栈 MSP);跑 FreeRTOS 时任务用进程栈 PSP,是 0xFFFFFFFD;中断嵌套时返回到上一层中断,是 0xFFFFFFF1。
  3. 处理函数结束时,把 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 辅助生成。

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐