如何解决FreeRTOS多线程信号量使用中出现的死锁问题？

// 任务 A：先拿 S1，再等 S2
void vTaskA(void *pv) {
    for (;;) {
        xSemaphoreTake(S1, portMAX_DELAY);  // 持有 S1
        xSemaphoreTake(S2, portMAX_DELAY);  // 等待 S2（任务 B 持有）
        // ... 操作资源 ...
        xSemaphoreGive(S2);
        xSemaphoreGive(S1);
    }
}

// 任务 B：先拿 S2，再等 S1
void vTaskB(void *pv) {
    for (;;) {
        xSemaphoreTake(S2, portMAX_DELAY);  // 持有 S2
        xSemaphoreTake(S1, portMAX_DELAY);  // 等待 S1（任务 A 持有）
        // ... 操作资源 ...
        xSemaphoreGive(S1);
        xSemaphoreGive(S2);
    }
}

结果：任务 A 和 B 互相等待，陷入死锁。

正确方式（统一顺序避免死锁）：

// 约定：所有任务先获取 S1，再获取 S2
void vTaskA(void *pv) {
    for (;;) {
        xSemaphoreTake(S1, portMAX_DELAY);  // 按顺序拿 S1
        xSemaphoreTake(S2, portMAX_DELAY);  // 再拿 S2
        // ... 操作资源 ...
        xSemaphoreGive(S2);
        xSemaphoreGive(S1);
    }
}

void vTaskB(void *pv) {
    for (;;) {
        xSemaphoreTake(S1, portMAX_DELAY);  // 同样先拿 S1（关键）
        xSemaphoreTake(S2, portMAX_DELAY);  // 再拿 S2
        // ... 操作资源 ...
        xSemaphoreGive(S2);
        xSemaphoreGive(S1);
    }
}

结果：即使任务 A 先持有 S1，任务 B 会等待 S1 释放，不会形成循环等待，避免死锁。

二、为信号量获取设置超时机制

原理

若任务获取信号量时设置有限超时时间（而非 portMAX_DELAY），当超时发生时，任务可释放已获取的信号量并重新尝试，避免永久阻塞。

示例代码

void vTaskWithTimeout(void *pv) {
    BaseType_t xResult1, xResult2;
    for (;;) {
        // 第一步：获取 S1（超时 100ms）
        xResult1 = xSemaphoreTake(S1, pdMS_TO_TICKS(100));
        if (xResult1 == pdPASS) {
            // 第二步：获取 S2（超时 100ms）
            xResult2 = xSemaphoreTake(S2, pdMS_TO_TICKS(100));
            if (xResult2 == pdPASS) {
                // 成功获取所有信号量，操作资源
                // ...
                xSemaphoreGive(S2);  // 释放 S2
            }
            xSemaphoreGive(S1);  // 无论 S2 是否获取成功，都释放 S1
        }

        // 超时后延迟一段时间再重试，避免频繁抢占 CPU
        vTaskDelay(pdMS_TO_TICKS(50));
    }
}

关键：超时后必须释放已获取的信号量（如示例中释放 S1），打破资源持有状态。

三、减少信号量的嵌套使用

原理

死锁风险与信号量嵌套层数正相关（嵌套越多，循环等待概率越高）。尽量避免一个任务同时持有多个信号量，若必须嵌套，控制嵌套深度（如最多 2 层）。

实践建议

将多个相关资源用一个信号量保护（而非每个资源一个信号量），降低嵌套需求。
例如：用一个 “UART 信号量” 保护 UART 发送缓冲区和接收缓冲区，而非分别用两个信号量。

四、实现死锁检测机制（调试阶段）

原理

在系统调试阶段，通过记录信号量的 “持有者” 和 “等待者”，定期检查是否存在循环等待链（如 A 等 B，B 等 C，C 等 A），一旦发现死锁则主动干预（如释放资源、复位任务）。

示例实现思路

为每个信号量维护一个结构体，记录当前持有者（任务句柄）和等待队列（等待该信号量的任务列表）。

typedef struct {
    SemaphoreHandle_t xSemaphore;
    TaskHandle_t xHolder;          // 当前持有者
    List_t xWaitList;              // 等待该信号量的任务
} SemaphoreInfo_t;

任务获取 / 释放信号量时，更新结构体信息（如 xSemaphoreTake() 后记录 xHolder 为当前任务）。

创建一个 “死锁检测任务”，定期遍历所有信号量的 xHolder 和 xWaitList，检查是否存在循环等待：

void vDeadlockCheckTask(void *pv) {
    for (;;) {
        if (xCheckForCircularWait() == pdTRUE) {  // 自定义检测函数
            // 死锁发生，执行干预（如打印日志、释放信号量）
            printf("Deadlock detected!\r\n");
            vForceReleaseSemaphores();  // 强制释放部分信号量
        }
        vTaskDelay(pdMS_TO_TICKS(100));  // 定期检测
    }
}

注意：死锁检测会增加系统开销，通常仅在调试阶段启用，量产阶段移除。

五、任务退出前释放所有持有的信号量

原理

若任务在持有信号量时被删除（如 vTaskDelete()），未释放的信号量会导致其他任务永久等待。需确保任务退出前主动释放所有持有的信号量。

示例代码

// 任务退出前的清理函数
void vTaskCleanup(TaskHandle_t xTask) {
    // 遍历任务持有的所有信号量并释放
    for (int i = 0; i < MAX_SEMAPHORES; i++) {
        if (xSemaphoreInfo[i].xHolder == xTask) {
            xSemaphoreGive(xSemaphoreInfo[i].xSemaphore);
            xSemaphoreInfo[i].xHolder = NULL;  // 清除持有者记录
        }
    }
}

// 删除任务时先执行清理
void vSafeDeleteTask(TaskHandle_t xTask) {
    vTaskCleanup(xTask);  // 释放持有的信号量
    vTaskDelete(xTask);
}