引言

在嵌入式实时系统（RTOS）中，任务优先级是调度核心。然而，当高优先级任务等待低优先级任务释放资源时，若中优先级任务抢占CPU，就会发生优先级反转，导致高优先级任务被无限期阻塞。在 ESP32 双核环境下，由于两个核心独立调度，问题更加复杂。本文将带你复现这一现象，并给出实用规避策略。

1. 优先级反转原理

优先级反转发生在三个不同优先级的任务共享一个互斥资源时：

高优先级任务 (H)：需要访问共享资源。
中优先级任务 (M)：不访问资源，但持续占用CPU。
低优先级任务 (L)：持有资源，但被M抢占。

理想调度顺序：H运行 → 等待资源 → L释放 → H继续。实际反转：H等待L，但M抢占L，导致H被M间接阻塞。

在单核中，可通过优先级继承缓解。但在ESP32双核中，两个核心独立运行，若H和L在不同核心，M在另一核心运行，则继承机制可能失效。

2. 环境准备

硬件：ESP32开发板（如ESP32-DevKitC）
软件：ESP-IDF v5.x，FreeRTOS（ESP-IDF自带）
配置：启用双核（默认），使用互斥锁（Mutex）

3. 复现优先级反转

3.1 代码设计

创建三个任务：

任务L：优先级1，获取互斥锁，然后延时（模拟持有资源）
任务M：优先级2，无锁，持续计算（模拟CPU密集）
任务H：优先级3，获取同一互斥锁，并记录等待时间

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

static const char *TAG = "PRIO_INV";
SemaphoreHandle_t mutex;

void task_L(void *arg) {
    while (1) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        ESP_LOGI(TAG, "L: got mutex, holding for 100ms");
        vTaskDelay(pdMS_TO_TICKS(100));
        xSemaphoreGive(mutex);
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void task_M(void *arg) {
    while (1) {
        // 模拟CPU密集操作
        volatile int x = 0;
        for (int i = 0; i < 1000000; i++) x++;
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}

void task_H(void *arg) {
    TickType_t start, end;
    while (1) {
        start = xTaskGetTickCount();
        xSemaphoreTake(mutex, portMAX_DELAY);
        end = xTaskGetTickCount();
        ESP_LOGI(TAG, "H: waited %d ms to get mutex", (end - start) * portTICK_PERIOD_MS);
        xSemaphoreGive(mutex);
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void app_main() {
    mutex = xSemaphoreCreateMutex();
    xTaskCreatePinnedToCore(task_L, "L", 2048, NULL, 1, NULL, 0);
    xTaskCreatePinnedToCore(task_M, "M", 2048, NULL, 2, NULL, 1);
    xTaskCreatePinnedToCore(task_H, "H", 2048, NULL, 3, NULL, 0);
}

3.2 运行结果

任务H和L在核心0，任务M在核心1。
当L持有互斥锁时，H等待。但M在核心1持续运行，不占用核心0，因此L能继续运行并释放锁，H等待时间约100ms。
若将M也放在核心0，则M会抢占L，导致H等待时间远超100ms，甚至可能达到数百ms，这就是优先级反转。

4. 规避策略

4.1 策略一：优先级继承

FreeRTOS互斥锁默认支持优先级继承。当H等待锁时，L的优先级临时提升到H的级别，从而避免被M抢占。

配置步骤：

使用xSemaphoreCreateMutex()创建互斥锁（已启用继承）。
确保所有任务使用同一互斥锁。

代码示例：无需修改，只需将任务M也放在核心0，观察效果。

// 修改app_main中任务M的创建
xTaskCreatePinnedToCore(task_M, "M", 2048, NULL, 2, NULL, 0); // 核心0

注意：优先级继承仅在单核内有效。在双核中，若L和H在不同核心，继承可能无法跨核传递。

4.2 策略二：优先级天花板

设置互斥锁的优先级天花板，即锁被持有时，持有者的优先级至少提升到天花板值。

配置步骤：

使用xSemaphoreCreateMutex()后，调用vSemaphoreSetPriority()（需自定义实现，FreeRTOS未直接提供）。
或使用xQueueCreateMutex并设置天花板。

代码示例：

// 自定义设置天花板（需修改FreeRTOS内核，不推荐）
// 推荐使用互斥锁+优先级继承，或改用信号量+互斥逻辑

4.3 策略三：使用互斥锁替代方案

使用二值信号量：但无继承，需手动处理。
使用临界区：仅用于短临界区，不适合长时间持有。
使用任务通知：轻量级同步，但需自行设计。

推荐：在ESP32双核中，使用xSemaphoreCreateRecursiveMutex()（递归互斥锁）并配合优先级继承，同时确保相关任务在同一核心运行，或使用xSemaphoreCreateMutex并接受跨核延迟。

5. 完整代码示例（规避后）

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_log.h"

static const char *TAG = "PRIO_FIX";
SemaphoreHandle_t mutex;

void task_L(void *arg) {
    while (1) {
        xSemaphoreTake(mutex, portMAX_DELAY);
        ESP_LOGI(TAG, "L: got mutex, holding for 100ms");
        vTaskDelay(pdMS_TO_TICKS(100));
        xSemaphoreGive(mutex);
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

void task_M(void *arg) {
    while (1) {
        volatile int x = 0;
        for (int i = 0; i < 1000000; i++) x++;
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}

void task_H(void *arg) {
    TickType_t start, end;
    while (1) {
        start = xTaskGetTickCount();
        xSemaphoreTake(mutex, portMAX_DELAY);
        end = xTaskGetTickCount();
        ESP_LOGI(TAG, "H: waited %d ms", (end - start) * portTICK_PERIOD_MS);
        xSemaphoreGive(mutex);
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void app_main() {
    mutex = xSemaphoreCreateMutex();
    // 将所有任务放在同一核心，确保优先级继承生效
    xTaskCreatePinnedToCore(task_L, "L", 2048, NULL, 1, NULL, 0);
    xTaskCreatePinnedToCore(task_M, "M", 2048, NULL, 2, NULL, 0);
    xTaskCreatePinnedToCore(task_H, "H", 2048, NULL, 3, NULL, 0);
}

运行后，H的等待时间应稳定在100ms左右，不再被M无限延长。

6. 注意事项

双核调度：ESP32的FreeRTOS默认支持双核，但任务优先级继承仅在同一核心内有效。若任务跨核，需使用xTaskCreatePinnedToCore指定核心，或使用队列等跨核同步机制。
优先级反转检测：可使用uxTaskGetStackHighWaterMark()监控任务栈，但无法直接检测反转。建议使用逻辑分析仪或记录等待时间。
避免长时间持有锁：即使有继承，长时间持有锁仍会阻塞高优先级任务。尽量缩短临界区。
使用互斥锁而非信号量：互斥锁自带优先级继承，信号量无此机制。
实时性评估：在系统设计时，通过vTaskSetTimeOutState设置超时，防止无限等待。

总结

优先级反转是RTOS开发中的经典陷阱。在ESP32双核环境下，由于多核调度，问题更隐蔽。通过复现实验，我们理解了其成因，并验证了优先级继承的有效性。实际项目中，应结合任务核心分配、锁持有时间控制，以及合理的优先级设计，才能确保系统实时性。希望本文能帮助你在嵌入式开发中少踩坑。

ESP32 双核环境下 FreeRTOS 任务优先级反转的复现与规避策略

引言