第四篇 FreeRTOS 同步机制：信号量、互斥量与优先级反转

掌握信号量与互斥量的原理和使用场景，深入理解优先级反转问题。这是 RTOS 面试中出现频率最高的知识点之一。本文从"为什么需要同步"讲起，带你彻底搞清楚二值信号量、计数信号量、互斥量的区别和实战用法。

一、为什么需要同步机制？

1.1 多任务并发问题

任务A: 读取温度 → [计算] → 写入全局变量 temp
任务B: 读取 temp → [显示到LCD]

问题：如果任务A写到一半被任务B抢占，B读到的就是"半成品"数据！

三大经典问题：

1. 竞态条件（Race Condition）：多任务同时访问共享资源
2. 数据不一致：读写被打断导致数据错乱
3. 执行顺序：任务间需要协调先后顺序

二、信号量（Semaphore）

2.1 二值信号量（Binary Semaphore）

就像一把只有一把钥匙的锁，只有 0 和 1 两种状态。

中断(Give)              二值信号量              任务(Take)
   │                     初始值=0                  │
   │── xSemaphoreGiveFromISR() ──→│  值=1           │
   │                              │── xSemaphoreTake() 成功 ──→│
   │                              │  值=0            │  执行处理逻辑

典型用途：中断与任务同步（中断 Give，任务 Take）

SemaphoreHandle_t xBinarySem;

// 初始化
xBinarySem = xSemaphoreCreateBinary();  // 初始值为0（空）

// 中断服务函数中
void EXTI0_IRQHandler(void)
{
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    xSemaphoreGiveFromISR(xBinarySem, &xHigherPriorityTaskWoken);

    // 如果唤醒了更高优先级的任务，触发上下文切换
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

// 任务中
void vProcessTask(void *pvParameters)
{
    for(;;)
    {
        // 等待信号量（阻塞直到中断Give）
        if(xSemaphoreTake(xBinarySem, portMAX_DELAY) == pdTRUE)
        {
            // 处理中断触发的事件
            ProcessData();
        }
    }
}

2.2 计数信号量（Counting Semaphore）

就像一个停车场计数器，记录可用资源数量。

// 创建：最大值10，初始值0
SemaphoreHandle_t xCountSem = xSemaphoreCreateCounting(10, 0);

// 生产者：释放资源
xSemaphoreGive(xCountSem);  // 计数+1

// 消费者：获取资源
xSemaphoreTake(xCountSem, portMAX_DELAY);  // 计数-1，为0时阻塞

典型用途：

1. 事件计数：记录中断发生次数（防止丢失）
2. 资源管理：管理有限资源池（如 DMA 通道、连接池）

2.3 二值信号量 vs 计数信号量

三、互斥量（Mutex）

3.1 为什么不能用二值信号量保护临界区？

任务A(低优先级): Take → 进入临界区 → [被抢占]
任务C(高优先级): Take → 阻塞等待...
任务B(中优先级): 一直在运行（不需要信号量）

结果：高优先级C被中优先级B间接阻塞了！→ 优先级反转！

3.2 互斥量 = 二值信号量 + 优先级继承

SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

void vTaskA(void *p)  // 低优先级
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY);
        // 访问共享资源（临界区）
        SharedResource++;
        xSemaphoreGive(xMutex);
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void vTaskC(void *p)  // 高优先级
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY);
        // 访问共享资源
        ReadSharedResource();
        xSemaphoreGive(xMutex);
        vTaskDelay(pdMS_TO_TICKS(50));
    }
}

3.3 优先级继承机制（核心重点）

低优先级任务A          中优先级任务B          高优先级任务C
      │                     │                     │
 持有 Mutex                 │                     │
 在临界区执行──────→        │              尝试 Take Mutex
      │                     │                  → 阻塞
 ┌────────────────────────────────────────────────┐
 │  A 的优先级被临时提升到与 C 相同！                    │
 │  B 无法抢占 A（A 现在优先级 = C）                    │
 └────────────────────────────────────────────────┘
      │                     │                     │
 释放 Mutex ─────────────────────────────→ 获得 Mutex
 优先级恢复原值             │               开始执行

3.4 信号量 vs 互斥量（高频面试题）

3.5 递归互斥量

// 同一任务可以多次 Take，不会死锁
SemaphoreHandle_t xRecMutex = xSemaphoreCreateRecursiveMutex();

void vTask(void *p)
{
    xSemaphoreTakeRecursive(xRecMutex, portMAX_DELAY);  // Take 1次
    FuncA();  // FuncA 内部也 Take 了一次
    xSemaphoreGiveRecursive(xRecMutex);  // Give 1次
}

void FuncA(void)
{
    xSemaphoreTakeRecursive(xRecMutex, portMAX_DELAY);  // Take 第2次（不会死锁）
    // ...
    xSemaphoreGiveRecursive(xRecMutex);  // Give 第2次
}

四、临界区保护的其他方式

4.1 关中断

taskENTER_CRITICAL();    // 关中断（允许嵌套）
// 临界区代码（尽量短！）
taskEXIT_CRITICAL();     // 开中断

// ISR版本
UBaseType_t uxSaved = taskENTER_CRITICAL_FROM_ISR();
// ...
taskEXIT_CRITICAL_FROM_ISR(uxSaved);

4.2 挂起调度器

vTaskSuspendAll();       // 暂停调度器（中断仍然开启）
// 临界区代码
xTaskResumeAll();        // 恢复调度器

4.3 三种临界区保护方式对比

五、实战练习

练习 1：中断同步 — 按键触发任务

SemaphoreHandle_t xButtonSem;

void vButtonTask(void *p)
{
    xButtonSem = xSemaphoreCreateBinary();
    for(;;)
    {
        if(xSemaphoreTake(xButtonSem, portMAX_DELAY) == pdTRUE)
        {
            printf("Button pressed! Processing...\r\n");
            HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
        }
    }
}

// EXTI中断回调
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    BaseType_t xWoken = pdFALSE;
    if(GPIO_Pin == BUTTON_Pin)
    {
        xSemaphoreGiveFromISR(xButtonSem, &xWoken);
        portYIELD_FROM_ISR(xWoken);
    }
}

练习 2：Mutex 保护共享资源

SemaphoreHandle_t xMutex;
uint32_t ulSharedCounter = 0;

void vIncrementTask(void *p)
{
    for(;;)
    {
        xSemaphoreTake(xMutex, portMAX_DELAY);
        for(int i = 0; i < 1000; i++)
            ulSharedCounter++;
        printf("Task%d: counter = %lu\r\n", (int)p, ulSharedCounter);
        xSemaphoreGive(xMutex);
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

// 创建两个同优先级任务，观察 counter 是否正确递增
xTaskCreate(vIncrementTask, "Inc1", 256, (void*)1, 2, NULL);
xTaskCreate(vIncrementTask, "Inc2", 256, (void*)2, 2, NULL);

六、面试高频问答

七、巩固练习题

选择题

填空题

简答题

八、总结 Checklist

• [ ] 理解信号量的 "Give / Take" 模型
• [ ] 区分二值信号量、计数信号量、互斥量的使用场景
• [ ] 能解释优先级反转及其解决方案
• [ ] 掌握 Mutex 的优先级继承机制
• [ ] 知道三种临界区保护方式的适用场景
• [ ] 完成中断同步实验
• [ ] 完成 Mutex 保护共享资源实验