#111_关于FreeRTOS面试的一些题目

RTOS 嵌入式秋招面试真经（适配你的Zephyr项目经历，可直接口述）

复制代码

核心原则：拒绝纯背理论，全部绑定项目现象、踩坑、排查过程，面试官不爱听课本原话，想听你实际遇到什么问题、怎么处理。

一、基础概念类（必问）

1.抢占式调度、时间片轮转区别

口述回答抢占式：高优先级任务就绪，立刻剥夺低优先级CPU使用权，马上运行；适合事件紧急业务，比如按键、传感器采集。时间片轮转：相同优先级任务，分配固定时间片，轮流执行，公平分配CPU。

复制代码

结合你的项目：Zephyr默认抢占为主，部分线程配置同优先级，开启时间片轮转。

2.任务栈溢出，现象+排查手段

现象：程序随机死机、hardfault、莫名其妙崩溃，不一定必现，复现飘忽。排查 1）开启栈水印检测，RTOS会在栈末尾填特殊标记； 2）看栈剩余使用统计； 3）调试器看栈指针SP是否超出栈空间；踩坑点：中断、函数局部大数组最容易吃栈，不要在函数内部定义大数组，改用全局或者堆。

复制代码

你的项目经历：做蓝牙鼠标驱动，一开始局部数组过大，偶发死机，调大线程栈、把数组移到全局解决。

二、同步互斥模块（最高频，优先级翻转、死锁必考）

3.信号量、互斥锁、事件标志组、消息队列区别

复制代码

二值信号量：任务和中断之间事件通知，资源可用/不可用；不拥有所有权。
互斥锁Mutex：保护共享资源，具备所有权，谁拿锁谁释放；支持优先级继承，专门缓解优先级翻转。
计数信号量：资源计数，比如多个硬件缓冲。
事件标志组：一位代表一个事件，可以等待多事件组合（或/与逻辑）。
消息队列：数据传递，任务‑任务、中断‑任务搬运数据，不光通知还能带数据。

面试避雷：不要拿二值信号量代替互斥锁！信号量没有所有权，别的任务可以随便释放，会引发逻辑错乱。

4.什么是优先级翻转？怎么解决

口述高优先级任务等待互斥锁，锁被低优先级任务持有；中间优先级任务就绪，抢占低优先级。导致最高优先级任务迟迟得不到CPU，系统实时性被破坏。解决：互斥锁开启优先级继承，Zephyr、FreeRTOS都支持。

复制代码

重点：普通信号量解决不了优先级翻转，必须用Mutex。

5.死锁四个条件，如何避免死锁

四个条件：互斥、占有且等待、不可剥夺、循环等待。规避手段： 1.尽量减少锁持有时间； 2.多个锁统一获取顺序； 3.增加获取锁超时时间，不要无限等待； 4.能不用锁就用队列、事件替代锁。

三、中断与RTOS API（高频挖坑题）

6.中断里面哪些API可以调用，哪些不能调用

1）中断上下文，只可以调用带ISR后缀的接口； 2）禁止：阻塞类API、延时、获取互斥锁、内存malloc；中断不能等待。

复制代码

你的项目：SPI传感器中断，只做最简单标记，把复杂处理交给工作线程，中断快进快出。

Tick时钟是什么？RTOS低功耗休眠如何配合tick

Tick是RTOS系统心跳，做任务时间片、延时、超时判断。低功耗模式：空闲线程进入休眠；关闭CPU内核时钟；等到tick中断或者外部硬件唤醒，退出休眠恢复任务调度。

复制代码

Zephyr支持tickless，闲置时可以关闭系统滴答，进一步降功耗，蓝牙设备很常用，贴合你的蓝牙鼠标项目。

四、项目深挖（重中之重，简历写Zephyr一定会问）

复制代码

下面是你可以直接背诵的项目口述模板 Q：你的Zephyr项目里面线程/任务怎么设计？ A：我做蓝牙鼠标项目，拆分多个线程：传感器采集线程、蓝牙HID上报线程；不同线程分配不同优先级。传感器采集优先级偏高，保证鼠标数据实时；蓝牙处理中等优先级。线程之间用消息队列传递采样数据，避免大量全局变量，减少锁的使用。

Q：项目遇到过哪些RTOS相关bug？如何定位？

复制代码

A：1.线程栈设置过小，偶发hardfault，开启栈水印定位，增大栈空间； 2.曾经错误在中断内调用阻塞接口，直接系统异常；后面严格区分中断上下文只做标记，业务逻辑丢给线程处理； 3.共享硬件寄存器访问，没加互斥锁，数据错乱，引入mutex保护。

五、面试避坑红线（短视频重点提醒）

1.不要只背定义，没有项目现象=低分； 2.不要混淆：互斥锁 vs 二值信号量；中断能不能延时； 3.不要说自己项目从来没有死机、没有bug，面试官不信；讲真实踩坑、排查过程是加分； 4.简历写了RTOS，必须把：任务、栈、互斥锁、队列、中断约束，全部吃透。

六、模拟自问自答快速复盘（面试前过一遍）

复制代码

互斥锁和二值信号量区别？优先级翻转怎么发生，怎么处理？
栈溢出现象，怎么排查？
中断里能调用k_sleep吗？为什么？
死锁四个条件，项目如何规避？
讲一段你项目中RTOS相关bug，复现现象、排查思路、最终修复。

素材二:

信号量 vs 互斥锁面试核心总结

这是面向嵌入式秋招的信号量与互斥锁专题讲解，核心解决90%工程师都会混淆的本质区别、适用场景和常见误用，是RTOS面试的高频考点。

一、核心本质区别

维度	互斥锁（Mutex）	信号量（Semaphore）
所有权	有，谁拿必须谁释放	无，任意任务/中断都可以释放
优先级继承	支持，解决优先级翻转	不支持，无法避免优先级翻转
递归锁	支持（同一任务可重复拿）	不支持，重复拿会导致死锁
跨任务释放	禁止，返回失败	允许，不同上下文可操作
中断中使用	禁止Take，可能导致系统卡死	允许使用`FromISR`版本API
典型用途	互斥访问共享资源	任务同步、中断通知、资源计数

一句话核心：互斥锁是"带主人的钥匙"，信号量是"无主的数字牌"，所有权是所有差异的根源。

二、适用场景

1. 必须用互斥锁的场景

保护全局变量、外设（SPI Flash、UART）、数据结构（链表）
同一时刻只能有一个任务访问的共享资源
核心特征：需要优先级继承，避免优先级翻转

2. 必须用信号量的场景

中断到任务的同步：中断里Give，任务里Take
任务间触发：任务A完成后Give，任务B等待Take
多资源计数：DMA通道池、内存块池、多实例外设（如3个UART）
核心特征：Give和Take的上下文不同，需要跨任务/中断操作

三、常见致命误用

1. 用二值信号量当互斥锁（定时炸弹）

无优先级继承：低优先级持有锁时，高优先级任务会被中间优先级任务抢占，导致系统实时性失效
跨任务释放：任意任务都能释放锁，会导致数据错乱、系统崩溃
调试困难：没有所有权记录，问题复现难，串口打印都无法定位

2. 用互斥锁做任务同步（死锁套餐）

中断里Take互斥锁：中断优先级高于所有任务，持有锁的任务永远无法释放锁，系统直接卡死
跨任务释放互斥锁：FreeRTOS会直接拒绝，返回失败，任务永远持有锁，导致死锁

四、面试标准答案（三句话）

本质区别：互斥锁有所有权，信号量没有，这是所有差异的根源。
场景判断：保护共享资源用互斥锁，任务同步和资源计数用信号量；N=1用Mutex，N>1用Semaphore。
加分项：互斥锁支持优先级继承，因为记录了持有者；信号量不支持，因为数学上不可行。

五、快速选择铁律

互斥访问（同一时刻1个任务访问）→ 用互斥锁
同步通知（ISR→任务、任务→任务）→ 用信号量
多个同类资源管理→ 用计数信号量

六、代码示例

互斥锁正确用法（保护全局变量）

c 复制代码

SemaphoreHandle_t xMutex;
int g_shared_data = 0;

void Task_SafeWrite(void *pv) {
    for (;;) {
        // 最多等100ms，拿不到就算了
        if (xSemaphoreTake(xMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
            g_shared_data++; // 临界区：放心改
            xSemaphoreGive(xMutex); // 自己拿的，自己还
        }
        vTaskDelay(pdMS_TO_TICKS(50)); // 延迟在锁外面
    }
}

信号量正确用法（中断通知任务）

c 复制代码

SemaphoreHandle_t xSem; // 信号量，初始值=0

// 中断服务程序
void UART_RX_ISR(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSem, &xHigherPriorityTaskWoken); // ISR里专用API
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 等待数据的任务
void Task_Process(void *pv) {
    for (;;) {
        xSemaphoreTake(xSem, portMAX_DELAY); // 死等数据
        process_received_data(); // 拿到信号，处理
    }
}

核心提醒：互斥锁的"同一任务Take/Give"是安全机制，不是限制，打破这个规则就是找死；信号量的跨任务释放能力，恰恰是同步场景需要的。

素材三

FreeRTOS 互斥锁面试核心笔记（可直接口述）

核心原则：用生活类比讲透原理，用项目踩坑证明理解，用代码细节体现实操能力，面试官不爱听纯理论，想听你"遇到过什么问题、怎么解决的"。

一、互斥锁是什么？（用面试官听得懂的类比）

口述回答

互斥锁就是单片机里的"交通警察"，或者说"单间厕所的旋钮锁"------同一时刻只允许一个任务进入临界区（共享资源），其他人必须在外面排队。

它有三个核心特征：

唯一持有：同一时间只有1个任务能拿到锁
谁拿谁还：锁的持有者必须自己释放，别人不能代劳
排队等待：拿不到锁的任务会挂起，不浪费CPU

为什么不用信号量代替？

互斥锁有所有权概念，这是信号量没有的，也是它能解决优先级翻转的根本原因。

二、为什么必须用互斥锁？（讲清楚问题根源）

口述回答

如果不用互斥锁，会出现两个致命问题：

竞争条件：多个任务同时访问共享资源，就像三个人同时冲进同一个单间厕所，画面混乱，数据全乱套。
数据竞争："读-改-写"不是原子操作，比如任务A和任务B同时读count=100，各自加1后都写回101，明明加了两次结果只加了1，这是嵌入式排名第一的Bug制造机。

三、互斥锁 vs 信号量（面试必问，直接说区别）

维度	互斥锁（Mutex）	信号量（Semaphore）
所有权	有，谁拿必须谁释放	无，任意任务/中断都可以释放
优先级继承	支持，解决优先级翻转	不支持，无法避免优先级翻转
递归使用	支持（递归互斥锁）	不支持，重复拿会导致死锁
跨任务释放	禁止，返回失败	允许，不同上下文可操作
中断中使用	禁止Take，可能导致系统卡死	允许使用`FromISR`版本API
典型用途	互斥访问共享资源	任务同步、中断通知、资源计数

一句话总结：互斥锁是"带主人的钥匙"，信号量是"无主的数字牌"，所有权是所有差异的根源。

四、优先级翻转（面试高频考点，必须讲透）

口述回答

高优先级任务等待互斥锁，锁被低优先级任务持有；中间优先级任务就绪，抢占低优先级。导致最高优先级任务迟迟得不到CPU，系统实时性被破坏，这就是优先级翻转。

解决方法 ：互斥锁开启优先级继承，FreeRTOS会把持有锁的低优先级任务的优先级临时提升到等待者中最高的优先级，锁释放后自动恢复原优先级，干净利落，没有副作用。

重点：普通信号量解决不了优先级翻转，必须用互斥锁。

五、互斥锁内部原理（体现你懂底层）

口述回答

互斥锁内部就两样东西：

等待队列：拿不到锁的任务挂在这个队列上，FIFO先进先出
所有者指针：记录当前谁持有锁，Take时记录，Give时检查

Take时：检查所有者，如果空就把自己写进去，否则进队列挂起。

Give时：归还优先级，唤醒队列下一个任务，就这么简单，没有魔法。

六、API实战（讲细节，体现你写过代码）

1. 创建互斥锁

c 复制代码

// 前提：FreeRTOSConfig.h 中 configUSE_MUTEXES 必须设为1
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();
if (xMutex == NULL) {
    // 内存不足，创建失败
}
// 创建后初始状态为"未锁定"，可直接Take

2. 拿锁和还锁

c 复制代码

// 拿锁
xSemaphoreTake(xMutex, pdMS_TO_TICKS(100)); // 超时100ms
// 返回pdTRUE：拿到了；pdFALSE：超时没拿到
// 重点：一定要设超时，别傻傻等，除非你百分百确定能拿到

// 还锁
xSemaphoreGive(xMutex);
// 返回pdTRUE：释放成功；pdFALSE：你不是锁的主人，释放失败

铁律：Take和Give必须成对出现，Take一次，Give一次，少一个都不行。

3. 递归互斥锁（特殊场景用）

普通互斥锁同一个任务不能重复Take，会直接死锁；递归互斥锁可以，内部有计数器，锁N次需要解N次。

c 复制代码

// 创建递归互斥锁
SemaphoreHandle_t xRecursiveMutex = xSemaphoreCreateRecursiveMutex();
// 拿锁
xSemaphoreTakeRecursive(xRecursiveMutex, pdMS_TO_TICKS(100));
// 还锁
xSemaphoreGiveRecursive(xRecursiveMutex);

七、项目实战（结合你的经历，面试官最爱听）

实战1：保护全局变量

c 复制代码

SemaphoreHandle_t xMutex;
int g_counter = 0;

void Task_Update(void *pv) {
    for (;;) {
        if (xSemaphoreTake(xMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
            g_counter++; // 临界区：只有我在改
            xSemaphoreGive(xMutex); // 改完立刻释放
        }
        vTaskDelay(pdMS_TO_TICKS(50)); // 延迟放在外面，别在锁里睡
    }
}

金句：临界区越短越好，别在锁里调用vTaskDelay、别在锁里等消息、别在锁里干重活。

实战2：两个任务抢打印机

不加锁的话，任务1打上半页，任务2插进来打下半页，拼出一个四不像；加锁后，谁先拿到锁谁完整打完，另一个在外面等，就像公司的公共打印机，不排队就乱套。

八、常见坑（讲你踩过的坑，加分项）

1. 死锁

场景：任务A持有锁1，等待锁2；任务B持有锁2，等待锁1，互相瞪眼，永远卡死。

解决方法：

统一所有任务的加锁顺序，所有任务都按"先锁1后锁2"的顺序拿锁
超时回退：拿不到锁就释放自己手上的锁，回头再试
尽量减少多锁场景，能用一把锁就别用两把

2. 忘了还锁

场景：Take了锁，函数中间某个if分支return了，忘了Give，锁永远不会被释放，所有等它的任务全部卡死。

解决方法：用goto cleanup模式，或者写个RAII wrapper，保证无论怎么退出都会Give。

九、互斥锁三条铁律（背下来，面试直接说）

临界区尽量短：进去就出来，别磨蹭
别在锁里调用阻塞API：vTaskDelay、xQueueReceive等可能阻塞的函数，在锁外调用
统一加锁顺序：所有任务按同一顺序获取多把锁，从源头消灭死锁

十、面试标准答案（三句话，直接背）

本质区别：互斥锁有所有权，信号量没有，这是所有差异的根源。
场景判断：保护共享资源用互斥锁，任务同步和资源计数用信号量；N=1用Mutex，N>1用Semaphore。
加分项：互斥锁支持优先级继承，因为记录了持有者；信号量不支持，因为数学上不可行。

十一、快速复盘（面试前过一遍）

互斥锁和信号量的核心区别？
优先级翻转是什么？怎么解决？
互斥锁的内部结构是什么？
递归互斥锁和普通互斥锁的区别？
互斥锁的三条铁律是什么？
讲一段你项目中互斥锁相关的bug，复现现象、排查思路、最终修复。

素材四:

FreeRTOS 同步互斥与通信面试核心速记

核心原则：用一句话区分每个工具的定位，用场景判断代替死记硬背，面试官要的是"你知道什么时候用什么"，而不是"你能背出所有API"。

一、先搞懂三个核心概念

通信：任务之间传递数据（比如传感器数据、命令、状态）
同步：任务之间协调执行节奏（比如A任务做完，B任务才能开始）
互斥：多个任务抢同一个资源，保证同一时间只有一个任务能用（比如串口、SPI、全局变量）

一句话区分：通信是"传消息"，同步是"等时机"，互斥是"抢资源时排队"。

二、五大工具对比（面试必问）

工具	核心用途	典型场景	关键特点
队列（Queue）	任务间传数据，FIFO缓存	传感器数据上报、命令解析、生产消费模型	支持多数据、多任务读写，自带阻塞，数据不丢失
二值信号量	任务/中断同步、事件通知	中断通知任务、任务间触发	只有0/1两种状态，无所有权，可跨任务释放
计数信号量	多资源计数、限流	DMA通道池、内存块池、缓冲区管理	支持0~N个资源，可多任务同时占用
互斥锁（Mutex）	保护共享资源，防止竞争	串口printf、SPI Flash、全局变量、LCD屏幕	有所有权，支持优先级继承，禁止跨任务释放
事件组（Event Group）	等待多个事件组合	同时等待传感器就绪+数据准备完成	一位代表一个事件，支持"与/或"逻辑

三、每个工具的核心用法（面试直接说）

1. 队列（Queue）

核心：传数据的"管道"，任务A写，任务B读，FIFO先进先出。

适用场景：

传感器采集任务把数据传给处理任务
串口接收任务把命令传给解析任务
生产消费模型：生产者写队列，消费者读队列
API：

c 复制代码

// 创建队列，10个元素，每个元素大小4字节
QueueHandle_t xQueue = xQueueCreate(10, sizeof(uint32_t));
// 写队列
xQueueSend(xQueue, &data, pdMS_TO_TICKS(100));
// 读队列
xQueueReceive(xQueue, &data, pdMS_TO_TICKS(100));

铁律：队列是用来传数据的，不是用来当锁的！

2. 二值信号量

核心："开关"，0=没事件，1=有事件，用来通知。

适用场景：

中断里给任务发信号：UART接收完成，中断里Give，任务里Take
任务A完成后通知任务B：A做完Give，B等Take
API：

c 复制代码

// 创建二值信号量，初始值0
SemaphoreHandle_t xSem = xSemaphoreCreateBinary();
// 中断里Give
xSemaphoreGiveFromISR(xSem, &xHigherPriorityTaskWoken);
// 任务里Take
xSemaphoreTake(xSem, portMAX_DELAY);

铁律：二值信号量是用来通知的，不是用来保护共享资源的！

3. 计数信号量

核心："资源计数器"，初始值=N，用一个减一，还一个加一。

适用场景：

管理3个DMA通道：初始值3，任务Take占用，用完Give释放
管理10个内存块：初始值10，任务Take分配，用完Give回收
API：

c 复制代码

// 创建计数信号量，最大值5，初始值5
SemaphoreHandle_t xSem = xSemaphoreCreateCounting(5, 5);

铁律：计数信号量是用来管理多个相同资源的，不是用来同步的！

4. 互斥锁（Mutex）

核心："钥匙"，谁拿谁还，保护共享资源。

适用场景：

保护全局变量：多个任务同时读写一个变量
保护外设：SPI Flash、UART、IIC总线
保护数据结构：链表、队列的读写
API：

c 复制代码

// 创建互斥锁
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();
// 拿锁
xSemaphoreTake(xMutex, pdMS_TO_TICKS(100));
// 还锁
xSemaphoreGive(xMutex);

铁律：互斥锁是用来保护共享资源的，不是用来传数据的！

5. 事件组（Event Group）

核心："多事件触发器"，一位代表一个事件，支持"与/或"逻辑。

适用场景：

任务同时等待两个事件：传感器就绪（bit0）+ 数据准备完成（bit1），两个都到了才执行
任务等待任意一个事件：按键按下（bit0）或定时器超时（bit1），任意一个到了就执行
API：

c 复制代码

// 创建事件组
EventGroupHandle_t xEventGroup = xEventGroupCreate();
// 等待bit0和bit1都置1
xEventGroupWaitBits(xEventGroup, (1<<0)|(1<<1), pdTRUE, pdTRUE, portMAX_DELAY);
// 置bit0
xEventGroupSetBits(xEventGroup, (1<<0));

铁律：事件组是用来等待多个事件组合的，不是用来传数据的！

四、面试高频问题标准答案

1. 队列和信号量的区别？

回答：

队列是用来传数据的，支持多数据、多任务读写，自带阻塞，数据不丢失；
信号量是用来同步、通知、资源计数的，不传数据，只传状态；
队列是"管道"，信号量是"开关/计数器"。

2. 互斥锁和二值信号量的区别？

回答：

互斥锁有所有权，谁拿必须谁释放，支持优先级继承，禁止跨任务释放；
二值信号量没有所有权，任意任务/中断都可以释放，不支持优先级继承；
互斥锁是用来保护共享资源的，二值信号量是用来同步通知的。

3. 什么时候用队列，什么时候用信号量？

回答：

任务之间需要传数据，用队列；
任务之间只需要通知事件，不需要传数据，用二值信号量；
任务之间需要管理多个相同资源，用计数信号量。

4. 什么时候用互斥锁，什么时候用事件组？

回答：

多个任务抢同一个资源，用互斥锁；
任务需要等待多个事件组合，用事件组。

五、快速选择铁律（面试前过一遍）

传数据 → 用队列
通知事件 → 用二值信号量
管理多个资源 → 用计数信号量
保护共享资源 → 用互斥锁
等待多个事件组合 → 用事件组

一句话总结：通信传数据用队列，同步通知用信号量，互斥保护用互斥锁，多事件等待用事件组。

六、项目实战（结合你的经历）

实战1：传感器数据采集

传感器采集任务：采集数据，写入队列
数据处理任务：从队列读数据，处理后上报
用队列：数据不丢失，任务阻塞不浪费CPU

实战2：UART中断通知任务

UART中断：接收完成，Give二值信号量
串口处理任务：Take信号量，处理数据
用二值信号量：中断和任务同步，不浪费CPU

实战3：保护SPI Flash

多个任务需要读写SPI Flash
用互斥锁：同一时间只有一个任务能读写，防止数据错乱

实战4：等待传感器就绪+数据准备完成

传感器就绪：置bit0
数据准备完成：置bit1
任务等待bit0和bit1都置1，才执行
用事件组：支持"与"逻辑，灵活高效

七、面试避坑红线

不要用互斥锁当信号量用，不要用信号量当互斥锁用；
不要用队列当锁用，不要用锁当队列用；
不要在中断里用互斥锁的Take，不要在中断里用队列的Send/Receive（要用FromISR版本）；
不要在锁里调用阻塞API，不要在锁里传数据。

核心提醒：每个工具都有自己的定位，没有好坏，只有适不适合，选对了，代码就稳了。

#111_关于FreeRTOS面试的一些题目

信号量 vs 互斥锁 面试核心总结

一、核心本质区别

二、适用场景

1. 必须用互斥锁的场景

2. 必须用信号量的场景

三、常见致命误用

1. 用二值信号量当互斥锁（定时炸弹）

2. 用互斥锁做任务同步（死锁套餐）

四、面试标准答案（三句话）

五、快速选择铁律

六、代码示例

互斥锁正确用法（保护全局变量）

信号量正确用法（中断通知任务）

FreeRTOS 互斥锁面试核心笔记（可直接口述）

一、互斥锁是什么？（用面试官听得懂的类比）

二、为什么必须用互斥锁？（讲清楚问题根源）

三、互斥锁 vs 信号量（面试必问，直接说区别）

四、优先级翻转（面试高频考点，必须讲透）

五、互斥锁内部原理（体现你懂底层）

六、API实战（讲细节，体现你写过代码）

1. 创建互斥锁

2. 拿锁和还锁

3. 递归互斥锁（特殊场景用）

七、项目实战（结合你的经历，面试官最爱听）

实战1：保护全局变量

实战2：两个任务抢打印机

八、常见坑（讲你踩过的坑，加分项）

1. 死锁

2. 忘了还锁

九、互斥锁三条铁律（背下来，面试直接说）

十、面试标准答案（三句话，直接背）

十一、快速复盘（面试前过一遍）

FreeRTOS 同步互斥与通信 面试核心速记

一、先搞懂三个核心概念

二、五大工具对比（面试必问）

三、每个工具的核心用法（面试直接说）

1. 队列（Queue）

2. 二值信号量

3. 计数信号量

4. 互斥锁（Mutex）

5. 事件组（Event Group）

四、面试高频问题标准答案

1. 队列和信号量的区别？

2. 互斥锁和二值信号量的区别？

3. 什么时候用队列，什么时候用信号量？

4. 什么时候用互斥锁，什么时候用事件组？

五、快速选择铁律（面试前过一遍）

六、项目实战（结合你的经历）

实战1：传感器数据采集

实战2：UART中断通知任务

实战3：保护SPI Flash

实战4：等待传感器就绪+数据准备完成

七、面试避坑红线

信号量 vs 互斥锁面试核心总结

FreeRTOS 同步互斥与通信面试核心速记