罗罗编程学习记录 全栈面试题库
本页导航 展开查看

14.1.4 任务划分、优先级与栈设计

所属:全栈开发面试题库 / 14 物联网与嵌入式软件 / 14.1 实时调度与 RTOS

本节要解决的问题

RTOS 项目里"任务怎么拆、优先级怎么排、栈给多大"是面试高频,也是最容易拍脑袋的地方。本节解决四个具体问题:一是讲清任务划分的判断标准——什么时候拆任务(延迟隔离、阻塞隔离、优先级隔离),什么时候不拆(避免过度同步);二是把优先级分配从"经验值"变成"速率单调映射"——周期越短优先级越高,并给出反例;三是栈深估算从"拍 1024"变成"静态估算最坏调用链 + 运行时水位验证 + 20%~50% 余量";四是讲清静态创建与动态创建的工程取舍,以及 MPU 栈保护在安全项目里的必要性。

学习目标

学完本节,你应当能够:

  • 用"延迟隔离、阻塞隔离、优先级隔离"三个判据决定一个功能该不该拆成独立任务。
  • 按速率单调给周期任务分配优先级,并说明反例(事件驱动任务、后台任务)。
  • 给出一个任务的栈深估算过程,并用水位法验证。
  • 解释为什么安全项目倾向静态创建 + MPU 栈保护。

先修与前置

知识地图

任务划分判据
  延迟隔离: 硬实时动作 vs 软实时处理 → 拆
  阻塞隔离: 一个任务会阻塞等IO, 另一个不能被拖慢 → 拆
  优先级隔离: 不同实时等级 → 拆
  不拆: 同步紧密、共享数据多、合并后无阻塞

优先级分配
  周期任务: 周期越短优先级越高 (RM)
  事件任务: 按事件紧急度, 与周期无关
  后台任务: 最低优先级, 空闲时跑
  IDLE hook: 最低, 不能阻塞

栈深 = 最深调用链栈帧 + 上下文保存 + 库开销 + 中断嵌套 + 余量(20~50%)
验证: uxTaskGetStackHighWaterMark + 魔术字 + MPU

核心术语

  • 任务划分(Task Decomposition):把应用功能拆成独立任务的过程。
  • 优先级分配(Priority Assignment):给每个任务指定优先级数值。
  • 栈深(Stack Size):任务运行所需的最大栈字节数。
  • 栈水位(High Water Mark):任务运行以来栈使用的最低地址,反映实际用量。
  • 魔术字(Stack Fill):创建任务时把栈写成固定模式,运行后扫描未被动过的区域。
  • 静态创建(Static Creation):编译期分配 TCB 与栈,运行时不失败。
  • MPU 栈保护:在栈底设不可访问区域,溢出触发 MemManage 异常。
  • 任务亲和(Affinity):多核上限定任务在指定核运行。

覆盖范围

  • 任务划分三判据与反例
  • RM 优先级分配与事件任务特例
  • 栈深估算、水位验证与 MPU 保护
  • 静态创建与动态创建的取舍
  • 任务间通信与同步最小化
  • 死锁、活锁与 CPU 利用率统计

高频题速览

编号 题目 难度 频率
14.1.4-001 什么时候该拆任务?什么时候不该? 基础 ★★★★
14.1.4-002 优先级怎么分配?周期任务与事件任务有何不同? 基础 ★★★★★
14.1.4-003 栈深怎么估算?怎么验证? 基础 ★★★★★
14.1.4-004 栈溢出怎么发现?魔术字与 MPU 哪个好? 进阶 ★★★★
14.1.4-005 任务间通信:全局变量 vs 队列 vs 消息? 进阶 ★★★★
14.1.4-006 静态创建 vs 动态创建怎么选? 进阶 ★★★★
14.1.4-007 CPU 利用率怎么统计?idle hook 怎么用? 进阶 ★★★
14.1.4-008 任务死锁与活锁的典型成因? 高级 ★★★
14.1.4-009 多核上任务亲和怎么配? 高级 ★★★
14.1.4-010 怎么避免过度同步? 高级 ★★★

14.1.4-001 什么时候该拆任务?什么时候不该?

一句话结论

拆任务的三个判据是延迟隔离、阻塞隔离、优先级隔离:硬实时动作与软实时处理必须拆开;一个任务会阻塞等 IO、另一个不能被拖慢时拆开;不同实时等级的任务必须拆开。不拆的判据是:两个任务同步紧密、共享数据多、合并后没有阻塞点,合并反而减少上下文切换与同步开销。

概念解释

  • 延迟隔离:中断处理(< 10us)与协议解析(ms 级)拆开,否则 ISR 变长。
  • 阻塞隔离:网络发送会阻塞几百 ms,不能与传感器采样(1ms 周期)同任务。
  • 优先级隔离:安全停车(最高优先级)与日志上报(最低优先级)必须拆开。
  • 合并判据:两个功能总是一起做、共享大量状态、合并后无阻塞点。

原理流程

  1. 列出所有功能模块:传感器采样、协议解析、网络发送、日志、UI。
  2. 给每个功能标注:实时等级(硬/固/软)、阻塞行为(会等什么)、执行时间。
  3. 不同实时等级 → 拆;不同阻塞行为 → 拆;不同延迟要求 → 拆。
  4. 若两个功能总是同步做、共享数据多、合并后无阻塞 → 合并。
  5. 评估拆完后的同步开销:队列/信号量数量,避免"拆得太碎导致同步成本 > 切换成本"。

代码或图示

拆任务示例:
  传感器采样(1ms周期, 硬实时)  → 高优先级任务
  协议解析(收到包后, 固实时)   → 中优先级任务
  网络发送(阻塞, 软实时)      → 低优先级任务
  日志上报(非实时)             → 最低优先级任务 + idle hook

不拆示例:
  LED 状态机 + 按键扫描: 总是同步做, 无阻塞, 合并为一个 10ms 周期任务

常见误区

  • 误区:每个模块一个任务;正解:拆得太碎会导致任务数爆炸、同步开销大,应按实时等级与阻塞行为分组。
  • 误区:任务越少越好;正解:把硬实时与软实时塞一个任务,会让硬实时被软实时阻塞。
  • 误区:任务数等于模块数;正解:一个模块可以拆多个任务(如网络栈拆 RX/TX),一个任务也可以管多个模块。

追问

  • 任务数多少合适?答:小型 MCU(RAM < 64KB)3~7 个任务;中型(64~512KB)7~15 个;大型(> 512KB)15~30 个。机制上每个任务有独立栈(512~2048 字节),任务数直接决定 RAM 占用。边界在于:任务数多不代表实时性好,反而增加同步开销。延伸:经验法则是"按实时等级分层,每层一个或几个任务"。
  • 为什么硬实时与软实时不能同任务?答:同任务意味着软实时部分会推迟硬实时部分,且软实时部分可能阻塞。机制上任务是串行执行,没有内部优先级。边界在于:若软实时部分能拆成"事件触发 + 短执行",可在同任务里做。延伸:这是"线程化"与"事件驱动"的核心区别。
  • 合并任务的代价?答:合并后两个功能共享一个栈、一个优先级,无法单独优化;且合并后代码复杂度上升。机制上合并减少上下文切换,但增加耦合。边界在于:耦合高的合并会让修改一个功能影响另一个。延伸:用状态机把合并任务组织清晰,比硬塞两个循环好。

14.1.4-002 优先级怎么分配?周期任务与事件任务有何不同?

一句话结论

周期任务按速率单调分配:周期越短优先级越高(1ms 任务 > 10ms 任务 > 100ms 任务);事件任务按事件紧急度分配,与周期无关(按键中断唤醒的任务优先级高于网络接收);后台任务(日志、flush)放最低优先级,idle hook 用于最低优先级非阻塞工作。

概念解释

  • 速率单调(RM):周期越短优先级越高,是静态优先级调度的最优分配。
  • 事件任务:由中断或事件唤醒,优先级取决于事件紧急度。
  • 后台任务:非实时,空闲时跑,不能阻塞。
  • 空闲任务(IDLE):最低优先级,RTOS 自动创建,可挂 idle hook。

原理流程

  1. 列出所有周期任务:T1=1ms, T2=10ms, T3=100ms。
  2. 按 RM 分配:T1 优先级最高,T2 次之,T3 最低。
  3. 列出事件任务:安全中断(最高)、传感器采样(高)、按键(中)、网络(低)。
  4. 事件任务优先级按紧急度插入周期任务之间,不打破 RM 顺序。
  5. 后台任务与 idle hook 放最低,确保不抢占实时任务。

代码或图示

优先级(数值越小越高,FreeRTOS 0=最低, configMAX-1=最高):
  15  ← 安全停车 ISR 唤醒任务 (最高)
  14  ← 1ms 控制环
  12  ← 10ms 传感器采样
  10  ← 100ms 上报
   8  ← 按键事件
   6  ← 网络接收
   4  ← 日志任务
   0  ← IDLE (RTOS 自动创建)
/* FreeRTOS 优先级分配示例 */
xTaskCreate(control_task,  "ctrl",  512, NULL, 4, NULL);  /* 1ms, 高 */
xTaskCreate(sensor_task,   "sen", 1024, NULL, 3, NULL);   /* 10ms */
xTaskCreate(report_task,   "rep", 1024, NULL, 2, NULL);   /* 100ms */
xTaskCreate(log_task,      "log", 512, NULL, 1, NULL);   /* 日志 */
/* IDLE 由 RTOS 创建,优先级 0 */

常见误区

  • 误区:所有任务按模块重要性分配;正解:周期任务按 RM,事件任务按紧急度,模块重要性不是判据。
  • 误区:网络任务优先级高;正解:网络是软实时,延迟几百 ms 用户无感知,应放低优先级。
  • 误区:idle hook 里可以做阻塞工作;正解:idle hook 在 idle 任务上下文,阻塞会让系统无法进入低功耗。

追问

  • 事件任务优先级怎么定?答:按事件后果定——安全事件(过流、过热)最高,传感器采样(ms 级延迟)次高,用户输入(百 ms 延迟)中等,网络/日志(秒级延迟)最低。机制上事件任务优先级 = 事件违约后果的严重程度。边界在于:事件频率高时要当周期任务分析(用最小到达间隔)。延伸:把事件按"违约后果 × 频率"二维分类。
  • 为什么周期任务必须按 RM?答:RM 是静态优先级调度的最优分配,可证明在 RM 下可调度的任务集,任何其它静态分配都可调度。机制上 RM 让短周期任务先跑,避免长周期任务推迟短周期任务。边界在于:RM 前提是任务独立、D=T、无阻塞;有阻塞时要做响应时间分析。延伸:实际项目里 RM 是起点,再按阻塞调整。
  • 后台任务放最低会不会饿死?答:只要高优先级任务有阻塞点(等事件、延时),后台任务就能跑;若高优先级任务永不阻塞,后台任务饿死。机制上调度器只跑最高优先级就绪任务。边界在于:设计上必须保证高优先级任务有阻塞点,否则系统其它部分停摆。延伸:用"CPU 利用率统计"验证后台任务是否得到足够执行时间。

14.1.4-003 栈深怎么估算?怎么验证?

一句话结论

栈深 = 最深调用链栈帧总和 + 上下文保存(Cortex-M 异常 32 字节 + 软件保存 ~40 字节)+ 库开销(printf/snprintf/加解密 数百字节到数 KB)+ 中断嵌套 + 余量(20%~50%);验证靠运行时栈水位(uxTaskGetStackHighWaterMark)+ 魔术字填充,压测 72 小时取最坏值。

概念解释

  • 最深调用链:从任务入口到最深库函数的栈帧总和。
  • 上下文保存:异常入栈 8 个寄存器(32 字节),软件保存剩余寄存器。
  • 库开销:printf/malloc/TLS 握手常有数百字节到数 KB 固定消耗。
  • 栈水位:任务运行以来栈使用的最低地址,反映实际用量。
  • 魔术字:创建任务时把栈写成 0xA5,运行后扫描未被动过的区域。

原理流程

  1. 静态估算:从任务入口找最深调用链(含库函数),逐层累加栈帧。
  2. 加上上下文保存开销(异常 + 软件保存)。
  3. 加上库开销(实测 printf/snprintf 等)。
  4. 加上中断嵌套开销(若中断用任务栈)。
  5. 运行时验证:开 configCHECK_FOR_STACK_OVERFLOW=2,压测 72 小时,读 uxTaskGetStackHighWaterMark。
  6. 最终栈深 = 实测最坏用量 × 1.2~1.5,纳入 CI 回归。

代码或图示

/* 创建任务时指定栈大小(单位:字,4 字节) */
xTaskCreate(protocol_task, "proto", 512, NULL, 3, &h);  /* 512 字 = 2KB */

/* 压测后查询水位 */
UBaseType_t hw = uxTaskGetStackHighWaterMark(h);
/* hw 单位是字:剩余最小空闲字数 */
/* 若 hw = 100,说明用过 512-100=412 字 = 1648 字节 */

/* 栈溢出钩子 */
void vApplicationStackOverflowHook(TaskHandle_t t, char *name) {
    log_crash("stack overflow: %s", name);
    NVIC_SystemReset();
}
栈深估算示例(Cortex-M4,无 FPU):
  最深调用链: protocol_task → json_parse → snprintf ≈ 180 字节
  异常入栈:   8 regs × 4 = 32 字节
  软件保存:   ~40 字节
  snprintf:   内部缓冲(实现相关,实测 ~200 字节)
  中断嵌套:   2 层 × 32 = 64 字节
  合计实测:   ~520 字节 → 取 1024 字节(约 2 倍余量)

常见误区

  • 误区:所有任务给同一个栈大小;正解:栈需求差异极大(点灯 vs 协议解析),统一大栈浪费 RAM,统一小栈必然溢出。
  • 误区:任务跑起来没崩就证明栈够;正解:栈溢出往往破坏别的任务数据,表现为随机死机,必须用水位验证。
  • 误区:只看自己代码;正解:printf、浮点格式化、TLS 握手是栈消耗大户,必须实测。

追问

  • 为什么 printf 吃栈?答:printf 要处理格式串、变参、浮点格式化,内部有状态机与缓冲,newlib 的 printf 可达 500~1000 字节栈。机制上浮点格式化需要内部转换缓冲。边界在于:用 newlib-nano 的 printf 体积小很多,且不支持浮点格式化。延伸:实时项目用自定义日志函数(只支持整数与字符串),避免 printf。
  • 中断用任务栈还是独立栈?答:Cortex-M 默认中断用 MSP(主栈),任务用 PSP(进程栈),中断栈与任务栈独立统计。机制上 CONTROL 寄存器的 SPSEL 位决定当前栈指针。边界在于:若在中断里调 RTOS API,内核仍需用当前任务栈保存被切换任务上下文。延伸:FreeRTOS 可配置独立中断栈,把最坏嵌套与任务隔离开。
  • 栈水位多久读一次?答:压测阶段每次功能测试后读,量产阶段在 idle hook 里定期读(如每秒),异常时上报。机制上水位只减不增(栈使用的最低地址),读一次即可。边界在于:水位是历史最坏值,不代表当前瞬时值;当前栈使用可通过 SP 与栈底比较得到。延伸:量产设备把水位告警纳入监控,栈余量 < 20% 时上报。

14.1.4-004 栈溢出怎么发现?魔术字与 MPU 哪个好?

一句话结论

栈溢出发现有三层:魔术字填充(软件扫描,便宜但延迟到下次检查)、栈溢出钩子(任务切换时检查水位,FreeRTOS configCHECK_FOR_STACK_OVERFLOW=2)、MPU 栈保护(硬件级,溢出立即触发 MemManage 异常);安全项目必须用 MPU,量产项目用魔术字 + 钩子兜底。

概念解释

  • 魔术字填充:创建任务时把栈写成 0xA5,任务切换时检查栈底是否还是 0xA5。
  • 栈溢出钩子:任务切换时检查水位,低于阈值触发钩子。
  • MPU 栈保护:在栈底设 no-access 区域,越界访问立即 MemManage fault。
  • 三级防护:魔术字(便宜)+ 钩子(检测)+ MPU(硬件保护)。

原理流程

  1. 魔术字:pxPortInitialiseStack 把栈填充 0xA5,任务切换时检查栈底 16 字节是否被改。
  2. 钩子:configCHECK_FOR_STACK_OVERFLOW=2 时,任务切换时检查 SP 是否超出栈范围。
  3. MPU:配置 MPU 区域为栈底 32 字节 no-access,任务切换时重配 MPU。
  4. 溢出时:钩子记录日志并复位;MPU 触发 MemManage,在 Handler 里转储现场。
  5. 量产:魔术字 + 钩子做兜底,MPU 在安全项目启用。

代码或图示

/* FreeRTOS 配置 */
#define configCHECK_FOR_STACK_OVERFLOW   2
#define configUSE_MPU_SUPPORT            1   /* 启用 MPU */

/* MPU 配置:栈底保护区 */
void mpu_config_stack_protect(uint32_t stack_bottom, uint32_t stack_size) {
    ARM_MPU_Region_t region;
    region.RBAR = stack_bottom | MPU_RBAR_VALID_Msk;
    /* 栈底 32 字节 no-access */
    region.RASR = ARM_MPU_RASR(0, ARM_MPU_AP_NONE, 0, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_32B);
    ARM_MPU_SetRegion(0, &region);
}

常见误区

  • 误区:魔术字能立即发现溢出;正解:它在任务切换时才检查,溢出到检查之间可能已经破坏数据。
  • 误区:MPU 配置一次就够;正解:任务切换时要重配 MPU 区域(每个任务栈位置不同)。
  • 误区:栈溢出一定是自己任务的事;正解:栈溢出可能破坏别的任务的数据或 TCB,表现为随机死机。

追问

  • MPU 有多少个区域?答:Cortex-M3/M4 通常 8 个区域,Cortex-M7 可能 16 个。机制上区域数量有限,多任务时无法给每个任务单独区域。边界在于:通常只保护当前运行任务的栈,切换时重配。延伸:安全认证项目(IEC 61508)普遍要求 MPU 栈保护。
  • 魔术字检查的开销?答:每次任务切换检查 16 字节,约 10~20 周期,开销可忽略。机制上 configCHECK_FOR_STACK_OVERFLOW=2 比 =1 更严格(检查 SP 是否越界)。边界在于:检查只在任务切换时做,ISR 里的栈溢出不会立即发现。延伸:ISR 栈溢出靠 MSP 栈深 + MPU 保护。
  • 栈溢出后为什么系统不立即崩?答:溢出通常写在栈底之外的区域(别的任务数据、堆、TCB),这些区域不一定立即导致崩溃,但会慢慢破坏状态。机制上栈是向下生长,溢出写在栈底之下。边界在于:溢出写在代码段或只读数据会立即 HardFault,写在 RAM 其它区域可能静默运行几小时。延伸:这就是为什么必须用 MPU 硬件保护。

14.1.4-005 任务间通信:全局变量 vs 队列 vs 消息?

一句话结论

任务间通信按数据量与同步需求选:单标志位用任务通知或事件组;定长小数据(< 16 字节)用队列;大块数据用共享内存 + 引用计数 + 通知;全局变量只在单写者单读者 + 原子访问时用,否则必须加锁或用队列。

概念解释

  • 任务通知:一对一,32 位值,最轻量。
  • 队列:定长元素 FIFO,按值拷贝。
  • 共享内存:大块数据,配引用计数或通知。
  • 全局变量:单写单读 + 原子,否则要临界区或队列。

原理流程

  1. 判断数据量:< 4 字节 → 任务通知;4~64 字节 → 队列;> 64 字节 → 共享内存。
  2. 判断同步需求:单向通知 → 任务通知/事件组;双向请求-响应 → 队列;流数据 → DMA 环形缓冲。
  3. 全局变量:若单写单读 + 32 位原子访问(Cortex-M 单次读写),可无锁;否则加锁。
  4. 大块数据:写者准备好 buffer,把 buffer 句柄通过队列发给读者,读者用完归还。
  5. 避免共享可变状态:优先"消息传递"而不是"共享内存"。

代码或图示

/* 1) 单标志:任务通知 */
xTaskNotifyGive(other_task);

/* 2) 定长小数据:队列 */
typedef struct { uint32_t ts; uint8_t cmd; } msg_t;
QueueHandle_t q = xQueueCreate(8, sizeof(msg_t));
xQueueSend(q, &m, 0);

/* 3) 大块数据:共享 buffer + 队列传指针 */
uint8_t large_buf[2][1024];   /* 双缓冲 */
QueueHandle_t buf_q = xQueueCreate(2, sizeof(uint8_t*));

void producer(void) {
    uint8_t *buf = large_buf[0];
    fill_buffer(buf);
    uint8_t *send = buf;
    xQueueSend(buf_q, &send, 0);
}

/* 4) 全局变量:单写单读 + 原子 */
volatile uint32_t g_counter;   /* 中断写,任务读 */
void isr(void) { g_counter++; }

常见误区

  • 误区:所有任务间通信都用队列;正解:队列是按值拷贝,大块数据用共享内存 + 指针传递更高效。
  • 误区:全局变量加 volatile 就安全;正解:volatile 只防编译器优化,不保证原子性,多字节写会撕裂。
  • 误区:队列传指针最快;正解:传指针要解决所有权与生命周期,按值拷贝虽然多一次 memcpy,但避免悬垂指针。

追问

  • 为什么 volatile 不保证原子性?答:volatile 只告诉编译器不要优化访问,但不保证单次读写是原子的。机制上 Cortex-M 对 32 位对齐访问是原子的,但 64 位或非对齐访问会撕裂。边界在于:多写者场景即使单次原子也需要锁(写-读-写不是原子)。延伸:用 atomic 类型(C11 stdatomic.h)或 RTOS 队列更安全。
  • 共享内存怎么同步?答:单写单读用 SPSC 环形缓冲 + 内存屏障;多写多读用临界区或队列。机制上 SPSC 只需保证写者先写数据再更新索引,读者先读索引再读数据。边界在于:跨核共享还要考虑缓存一致性(DMB/DSB)。延伸:优先用内核队列,把同步交给内核。
  • 双缓冲怎么避免撕裂?答:写者写 buffer A,读者读 buffer B,写满后交换;读者永远不会读到半新半旧的数据。机制上交换是原子指针写(32 位)。边界在于:写者比读者快时会覆盖未读的 buffer,要加丢帧计数。延伸:这是视频、音频流的标准做法。

14.1.4-006 静态创建 vs 动态创建怎么选?

一句话结论

静态创建(xTaskCreateStatic / K_THREAD_DEFINE)在编译期分配 TCB 与栈,运行时不失败、无堆碎片、可预测,适合安全认证与资源极小 MCU;动态创建(xTaskCreate)从堆分配,灵活但可能失败、有碎片,适合原型阶段与负载可变的场景。

概念解释

  • 静态创建:编译期数组分配 TCB 与栈,运行时 xTaskCreateStatic 只初始化。
  • 动态创建:从 configTOTAL_HEAP_SIZE 分配,返回 NULL 表示失败。
  • 静态对象:Zephyr 全部内核对象支持 K_SEM_DEFINE 等静态宏。
  • 工程取舍:安全项目静态,原型项目动态。

原理流程

  1. 列出所有任务、队列、信号量、定时器。
  2. 安全认证项目:全部静态,编译期确定所有内存。
  3. 原型项目:动态,快速迭代。
  4. 量产项目:关键任务静态,可选任务动态。
  5. 静态创建要在链接脚本里给静态栈留足够 RAM,避免堆与静态栈冲突。

代码或图示

/* FreeRTOS 静态创建任务 */
static StackType_t  task_stack[512];
static StaticTask_t task_tcb;
TaskHandle_t h = xTaskCreateStatic(
    my_task, "my", 512, NULL, 3, task_stack, &task_tcb);

/* 静态队列 */
static StaticQueue_t q_cb;
static uint8_t q_storage[8 * sizeof(msg_t)];
QueueHandle_t q = xQueueCreateStatic(8, sizeof(msg_t), q_storage, &q_cb);

/* Zephyr 静态定义 */
K_THREAD_STACK_DEFINE(my_stack, 1024);
K_SEM_DEFINE(my_sem, 0, 1);
K_THREAD_DEFINE(my_tid, 1024, my_thread, NULL, NULL, NULL, 5, 0, 0);

常见误区

  • 误区:静态创建不灵活;正解:静态创建只是编译期分配,运行时仍可 vTaskDelete 删除,只是内存不归还堆。
  • 误区:动态创建简单;正解:动态创建要检查返回值、处理堆碎片、监控堆水位,量产项目反而更复杂。
  • 误区:静态创建浪费 RAM;正解:静态创建按实际需要分配,动态创建为了防碎片通常留更多余量。

追问

  • 安全认证为什么要求静态?答:静态分配在编译期确定所有内存,运行时不会失败(无 NULL 返回),且无堆碎片,可做 WCET 分析。机制上静态对象进 BSS,链接器保证地址有效。边界在于:C++ 项目若用了 new,需要把 new 重定向到静态池。延伸:IEC 61508、ISO 26262 都要求静态内存。
  • 静态创建的栈怎么在链接脚本里安排?答:静态栈是全局数组,进 BSS 段,链接脚本自动分配;堆在 BSS 末尾(_end 到 _estack)。机制上静态栈与堆共享 RAM,要确保不冲突。边界在于:静态栈太大挤压堆,堆太大会覆盖静态栈。延伸:用 map 文件检查静态栈与堆的地址范围。
  • 动态创建的失败怎么处理?答:检查返回值,失败时记录错误、安全降级、复位。机制上堆耗尽时返回 NULL。边界在于:运行时动态创建任务(如网络连接处理)失败会导致连接断开,要有降级路径。延伸:量产项目尽量避免运行时动态创建。

14.1.4-007 CPU 利用率怎么统计?idle hook 怎么用?

一句话结论

CPU 利用率靠 configGENERATE_RUN_TIME_STATS:每个任务在 vTaskSwitchContext 时累计运行时间,除以总时间得到利用率;idle hook 在 idle 任务上下文(最低优先级)运行,用于低优先级非阻塞工作(喂独立看门狗前的检查、LED 心跳、低功耗准备),不能阻塞。

概念解释

  • 运行时间统计:每个 TCB 记录 ulRunTimeCounter,任务切换时累计。
  • 时钟源:用一个高频定时器(如 1MHz)作为时基,portCONFIGURE_TIMER_FOR_RUN_TIME_STATS。
  • 利用率:任务运行时间 / 总时间 × 100%。
  • idle hook:idle 任务每次运行时调用,不能阻塞。

原理流程

  1. 配置 configGENERATE_RUN_TIME_STATS=1,提供高频定时器。
  2. 任务切换时,内核把当前任务的运行时间累计到 TCB。
  3. vTaskGetRunTimeStats() 输出每个任务的运行时间与百分比。
  4. idle hook 在 idle 任务上下文运行,做非阻塞工作。
  5. 长时统计:利用率高的任务是性能热点,利用率低的任务可能设计过度。

代码或图示

/* FreeRTOS 配置 */
#define configGENERATE_RUN_TIME_STATS    1
#define configUSE_IDLE_HOOK              1

/* 高频定时器:1MHz, 1us 精度 */
void configure_run_time_timer(void) {
    TIM2->PSC = (SystemCoreClock / 1000000) - 1;
    TIM2->ARR = 0xFFFFFFFF;
    TIM2->CR1 |= TIM_CR1_CEN;
}
uint32_t get_run_time_counter(void) { return TIM2->CNT; }

/* 输出任务利用率 */
char buf[512];
vTaskGetRunTimeStats(buf);
printf(buf);   /* 任务名 + 运行时间 + 百分比 */

/* idle hook:不能阻塞! */
void vApplicationIdleHook(void) {
    LED_Toggle();           /* 心跳 */
    check_low_power_ready(); /* 准备进低功耗 */
    /* 不能 vTaskDelay / xSemaphoreTake */
}

常见误区

  • 误区:idle hook 里可以做延时;正解:idle hook 在 idle 任务上下文,阻塞会让系统无法进低功耗。
  • 误区:利用率 100% 就是满负荷;正解:利用率统计包括 idle 任务,若 idle 占 5%,说明业务占 95%。
  • 误区:运行时间统计无开销;正解:每次任务切换累计时间,开销几周期,高频切换时要考虑。

追问

  • 利用率统计对实时性有什么用?答:它告诉你 CPU 花在哪个任务上,找出热点;利用率 > 80% 的系统要小心,因为中断与偶发任务会让峰值超过 100%。机制上利用率是平均,不反映峰值。边界在于:硬实时系统要留 20% 以上余量给中断与偶发任务。延伸:把利用率纳入 CI 监控,回归时报警。
  • idle hook 里能做什么?答:心跳 LED、低功耗准备(检查是否可进 Stop 模式)、喂独立看门狗前的检查、非阻塞日志 flush。机制上 idle hook 每次 idle 任务运行时调用,频率取决于业务负载。边界在于:任何可能阻塞的工作都不能放 idle hook。延伸:tickless 模式下 idle hook 还负责进入低功耗。
  • 怎么知道任务是否饿死?答:看 idle 任务的利用率——若 idle 占比 > 0,说明低优先级任务能跑;若 idle = 0,说明高优先级任务永不阻塞,低优先级任务饿死。机制上调度器只跑最高优先级就绪任务。边界在于:设计上必须保证高优先级任务有阻塞点。延伸:用 vTaskGetRunTimeStats 看每个任务是否得到执行时间。

14.1.4-008 任务死锁与活锁的典型成因?

一句话结论

死锁是两个任务互相等对方持有的锁,永远阻塞;活锁是任务都在运行但互相让步,永远做不了事。典型成因:加锁顺序不一致、持锁期间阻塞、ISR 与任务抢同一把锁、中断里等待信号量。

概念解释

  • 死锁(Deadlock):任务 A 等 B 的锁,B 等 A 的锁,双方永远阻塞。
  • 活锁(Livelock):任务都在运行,但互相让步,永远无法完成。
  • 加锁顺序:所有任务按相同顺序加锁,避免循环等待。
  • 持锁阻塞:持锁期间调用阻塞 API,会让锁被长期持有。

原理流程

  1. 死锁四条件:互斥、持有并等待、不可剥夺、循环等待。
  2. 破坏循环等待:所有任务按相同顺序加锁(如先锁 A 再锁 B)。
  3. 破坏持有并等待:一次性获取所有需要的锁。
  4. 持锁期间不阻塞:临界区内不调 vTaskDelay、xSemaphoreTake。
  5. ISR 不抢任务锁:ISR 用二值信号量/任务通知,不用互斥量。

代码或图示

/* 死锁:任务 A 先锁 M1 再锁 M2,任务 B 先锁 M2 再锁 M1 */
void task_A(void) {
    xSemaphoreTake(M1, portMAX_DELAY);
    xSemaphoreTake(M2, portMAX_DELAY);   /* 等 B 释放 M2 */
    /* ... */
}
void task_B(void) {
    xSemaphoreTake(M2, portMAX_DELAY);
    xSemaphoreTake(M1, portMAX_DELAY);   /* 等 A 释放 M1 */
    /* 死锁 */
}

/* 正解:统一加锁顺序 */
void task_A(void) {
    xSemaphoreTake(M1, portMAX_DELAY);
    xSemaphoreTake(M2, portMAX_DELAY);
    /* ... */
    xSemaphoreGive(M2);
    xSemaphoreGive(M1);
}
void task_B(void) {
    xSemaphoreTake(M1, portMAX_DELAY);   /* 同样先 M1 再 M2 */
    xSemaphoreTake(M2, portMAX_DELAY);
    /* ... */
}

常见误区

  • 误区:死锁只在多任务时发生;正解:ISR 与任务也能死锁(ISR 等任务持有的锁)。
  • 误区:加超时就能避免死锁;正解:超时只是让等待失败,但死锁根因仍在,超时后重试可能再次死锁。
  • 误区:持锁期间 vTaskDelay 没事;正解:持锁期间延时会让锁被长期持有,形成阻塞。

追问

  • 怎么调试死锁?答:用调试器暂停系统,查看每个任务的栈与等待对象,找出循环等待链。机制上死锁时所有相关任务都在阻塞态,栈指向 xSemaphoreTake。边界在于:偶发死锁难复现,要加日志记录加锁顺序与等待对象。延伸:用 trace 工具记录每次加锁/解锁,回放死锁现场。
  • 活锁是什么场景?答:两个任务都在检测到冲突时退让,结果双方都在退让,永远做不了事。机制上类似交通路口两车互相让路。边界在于:活锁比死锁更难发现,因为 CPU 在跑但系统不进展。延伸:用随机退让或优先级固定解决。
  • ISR 与任务怎么避免死锁?答:ISR 不用互斥量,只用二值信号量/任务通知/队列;任务侧用互斥量保护共享数据,ISR 侧只发通知。机制上 ISR 没有 TCB,不能阻塞等待互斥量。边界在于:ISR 与任务共享数据时,任务侧要进临界区,ISR 侧要用 FromISR API。延伸:这是 ISR 设计的基本原则。

14.1.4-009 多核上任务亲和怎么配?

一句话结论

多核上把硬实时任务绑核(affinity),避免跨核迁移带来的抖动;通信协议栈与后台任务留在其它核,利用 SMP 自动负载均衡;核间通信用无锁 SPSC 队列 + IPI,避免跨核锁。

概念解释

  • 任务亲和(Affinity):限定任务只能在指定核运行。
  • 绑核:硬实时任务绑到固定核,避免迁移抖动。
  • SMP 负载均衡:任务默认可迁移,内核自动调度。
  • 核间通信:SPSC 队列 + IPI,避免锁。

原理流程

  1. 识别硬实时任务(控制环、采样),绑到核 0。
  2. 识别软实时任务(协议栈、日志),留在核 1 或允许迁移。
  3. 核间共享数据用 SPSC 队列 + 内存屏障。
  4. 跨核唤醒用 IPI,避免目标核在低功耗看不到就绪队列变化。
  5. 测量绑核后的抖动,与不绑核对比。

代码或图示

/* FreeRTOS SMP:绑核 */
TaskHandle_t h = xTaskCreateStatic(...);
vTaskCoreAffinitySet(h, (1UL << 0));   /* 只在核 0 */

/* Zephyr SMP:绑核 */
K_THREAD_DEFINE(ctrl_tid, 1024, ctrl_thread, NULL, NULL, NULL,
                -1, 0, 0);
k_thread_cpu_mask_set(ctrl_tid, BIT(0));

/* 核间 SPSC 队列 + IPI */
typedef struct { volatile uint32_t head, tail; uint8_t buf[256]; } ring_t;
void core_a_send(ring_t *r, uint8_t v) {
    r->buf[r->head] = v;
    __DMB();
    r->head = (r->head + 1) % 256;
    ipi_trigger(CORE_B_IRQn);
}

常见误区

  • 误区:多核就能提升实时性;正解:核间共享总线、共享缓存会引入新干扰,硬实时核必须隔离资源。
  • 误区:绑核后实时性一定好;正解:绑核避免迁移抖动,但也可能让某核过载,要按负载规划。
  • 误区:跨核共享数据用关中断保护;正解:关中断只影响本核,另一核仍可并发,必须加自旋锁或无锁结构。

追问

  • 为什么绑核能减少抖动?答:任务迁移时缓存与分支预测冷启动,导致响应时间变长;绑核后任务一直在同一核,缓存局部性好。机制上迁移要保存/恢复上下文,且新核缓存为空。边界在于:绑核后若该核负载过高,任务无法迁移到空闲核。延伸:硬实时任务绑核 + 资源隔离(独立定时器、独立 DMA)是标准做法。
  • 跨核共享数据怎么保护?答:单写单读用 SPSC 无锁队列;多写多读用自旋锁 + 内存屏障。机制上自旋锁忙等,关本核中断,跨核互斥。边界在于:自旋锁临界区必须极短(几十条指令),否则浪费 CPU。延伸:优先设计成无锁单向数据流。
  • 核间时间基准怎么统一?答:用同一个硬件时基(如共享系统定时器),或每核独立定时器 + 周期性对齐。机制上单一时间基准保证事件排序一致。边界在于:各核独立定时器有晶振偏差,长时间要校正。延伸:需要严格事件排序时用全局时间戳计数器(如 ARM CNTPCT)。

14.1.4-010 怎么避免过度同步?

一句话结论

过度同步的根因是"共享可变状态过多",解决思路是减少共享数据、把数据所有权分配给单一任务、用消息传递代替共享内存;具体手法:每个模块只让一个任务写自己的状态、只读数据不加锁、用事件驱动替代轮询。

概念解释

  • 共享可变状态:多个任务读写同一变量,必须同步。
  • 数据所有权:每个数据块只让一个任务写,其它任务通过消息获取。
  • 消息传递:任务间通过队列传递数据副本,不共享内存。
  • 事件驱动:任务只在事件发生时唤醒,不空转轮询。

原理流程

  1. 审查共享数据:列出所有多任务读写的变量。
  2. 给每个数据指定唯一写者:其它任务只能读或通过消息获取。
  3. 只读数据:初始化后不修改,不加锁。
  4. 必须共享的:用队列传数据副本,不用全局变量。
  5. 轮询改事件:任务阻塞等事件,不空转。

代码或图示

/* 过度同步:多个任务都读 g_sensor_data */
volatile float g_sensor_data;
void sensor_task(void) { g_sensor_data = read_sensor(); }
void log_task(void)     { float v = g_sensor_data; log(v); }
void report_task(void)  { float v = g_sensor_data; report(v); }

/* 正解:sensor_task 拥有数据,通过队列分发 */
void sensor_task(void) {
    for (;;) {
        float v = read_sensor();
        xQueueSend(log_q, &v, 0);
        xQueueSend(report_q, &v, 0);
    }
}
void log_task(void) {
    float v;
    for (;;) {
        xQueueReceive(log_q, &v, portMAX_DELAY);
        log(v);
    }
}

常见误区

  • 误区:加锁越多越安全;正解:加锁越多越慢、越容易死锁,应减少共享状态。
  • 误区:全局变量方便;正解:全局变量是耦合之源,应通过消息传递。
  • 误区:轮询简单;正解:轮询浪费 CPU、增加同步点,应改事件驱动。

追问

  • 怎么判断数据是否需要加锁?答:单写单读 + 32 位原子访问可无锁;多写或非原子必须加锁。机制上 Cortex-M 对 32 位对齐访问是原子的。边界在于:读-改-写(如 g_counter++)不是原子,即使单写也要加锁。延伸:用 atomic 类型或 RTOS 队列。
  • 消息传递比共享内存慢吗?答:消息传递有 memcpy 开销,但避免了锁与同步,整体在高争用场景下更快。机制上共享内存要加锁,锁竞争导致阻塞;消息传递无锁,并行性好。边界在于:大块数据(> 1KB)memcpy 开销大,应共享内存 + 引用计数。延伸:这是"共享内存 vs 消息传递"经典争论。
  • 事件驱动怎么减少同步?答:事件驱动让任务只在有事时唤醒,避免轮询时共享状态。机制上轮询时多个任务频繁读同一变量,事件驱动只在变化时通知。边界在于:事件驱动需要事件源,周期任务仍需定时唤醒。延伸:结合 tickless,事件驱动 + 低功耗是最优。

动手练习

练习 1:为你的项目设计任务划分与优先级

  • 任务:列出项目所有功能模块,按延迟/阻塞/优先级三判据拆任务,给出任务表(任务名、周期、优先级、栈大小)。
  • 验收标准:
    1. 每个任务标注实时等级(硬/固/软)与截止时间。
    2. 周期任务按 RM 分配优先级,事件任务按紧急度插入。
    3. 栈深估算过程清晰,包含库开销与中断嵌套。

练习 2:用栈水位法验证栈深

  • 任务:给每个任务开 configCHECK_FOR_STACK_OVERFLOW=2,压测 72 小时,读 uxTaskGetStackHighWaterMark,与估算值对比。
  • 验收标准:
    1. 给出每个任务的估算栈深、实测水位、最终栈深(含余量)。
    2. 指出哪个任务的栈深估算偏差最大,原因是什么。
    3. 把栈深纳入 CI 监控(回归时报警)。

自检清单

  • [ ] 能否用三判据决定任务拆分?
  • [ ] 能否按 RM 给周期任务分配优先级?
  • [ ] 能否给出栈深估算过程并用水位验证?
  • [ ] 能否对比魔术字、栈钩子、MPU 三种溢出检测?
  • [ ] 能否选择任务间通信方式(通知/队列/共享内存)?
  • [ ] 能否解释静态创建与动态创建的取舍?
  • [ ] 能否用运行时间统计找出性能热点?
  • [ ] 能否设计避免死锁的加锁顺序?

延伸阅读

  • FreeRTOS 官方文档:Task Creation、Stack Overflow、Run Time Stats、Static Allocation。
  • Zephyr 官方文档:Threads、Scheduling、SMP、Affinity。
  • 正 Heinzmann, "Using the FreeRTOS Real Time Kernel: A Practical Guide"。
  • ARM Cortex-M 权威指南(Joseph Yiu):MPU、栈保护、多核。
  • 设计模式:Active Object、Producer-Consumer、Double Buffering。

待整理清单

  • [ ] 补充不同 MCU 上静态栈与堆的链接脚本示例对比
  • [ ] 补充 Zephyr 与 FreeRTOS 在多核绑核 API 上的差异
  • [ ] 补充任务利用率在 OTA 升级场景下的峰值数据