ESP32-Wroom自定义任务队列随机停止问题求助

• 数据竞争风险：你未提供enqueueTask、processPendingTasks、removeCompletedTasks的实现，但跨核心访问队列时如果没有正确的锁保护，会直接破坏队列结构，导致程序随机崩溃。
• std::mutex的FreeRTOS适配问题：ESP32 Arduino环境中，std::mutex基于FreeRTOS信号量实现，但任务优先级设置不当或锁使用逻辑错误时，容易引发调度阻塞。
• 任务循环调度异常：原循环里的delay(1)虽然会让渡CPU，但如果队列操作逻辑耗时极短，任务会频繁抢占CPU时间片，导致系统调度失衡；添加Serial.println或增大延迟只是让任务让渡CPU的时间更长，掩盖了根本问题。

1. 补全队列操作的锁保护逻辑 #

所有访问pendingTasksQueue和executedTasks的操作必须在互斥锁保护下，先给出标准C++互斥锁的实现：

void TasksQueue::enqueueTask(std::unique_ptr<Task> task)
{
    std::lock_guard<std::mutex> guard(lock);
    pendingTasksQueue.push(std::move(task));
}

void TasksQueue::processPendingTasks()
{
    std::lock_guard<std::mutex> guard(lock);
    while (!pendingTasksQueue.empty())
    {
        auto task = std::move(pendingTasksQueue.front());
        pendingTasksQueue.pop();
        task->start();
        executedTasks.push_back(std::move(task));
    }
}

void TasksQueue::removeCompletedTasks()
{
    std::lock_guard<std::mutex> guard(lock);
    executedTasks.erase(
        std::remove_if(executedTasks.begin(), executedTasks.end(),
            [](const std::unique_ptr<Task>& task) {
                return task->update();
            }),
        executedTasks.end()
    );
}

2. 替换为FreeRTOS原生互斥锁（更可靠） #

ESP32基于FreeRTOS，使用原生互斥锁能避免C++标准库与FreeRTOS调度的兼容性问题：
先修改TasksQueue的私有成员和构造/析构函数：

private:
    SemaphoreHandle_t lock; // 替换std::mutex
    std::queue<std::unique_ptr<Task>> pendingTasksQueue;
    std::vector<std::unique_ptr<Task>> executedTasks;

    TasksQueue() {
        // 创建递归互斥锁，支持同一任务多次加锁
        lock = xSemaphoreCreateRecursiveMutex();
    }

    ~TasksQueue() {
        vSemaphoreDelete(lock);
    }

再更新队列操作的锁逻辑：

void TasksQueue::enqueueTask(std::unique_ptr<Task> task)
{
    if (xSemaphoreTakeRecursive(lock, portMAX_DELAY) == pdTRUE) {
        pendingTasksQueue.push(std::move(task));
        xSemaphoreGiveRecursive(lock);
    }
}

void TasksQueue::processPendingTasks()
{
    if (xSemaphoreTakeRecursive(lock, portMAX_DELAY) == pdTRUE) {
        while (!pendingTasksQueue.empty())
        {
            auto task = std::move(pendingTasksQueue.front());
            pendingTasksQueue.pop();
            task->start();
            executedTasks.push_back(std::move(task));
        }
        xSemaphoreGiveRecursive(lock);
    }
}

void TasksQueue::removeCompletedTasks()
{
    if (xSemaphoreTakeRecursive(lock, portMAX_DELAY) == pdTRUE) {
        executedTasks.erase(
            std::remove_if(executedTasks.begin(), executedTasks.end(),
                [](const std::unique_ptr<Task>& task) {
                    return task->update();
                }),
            executedTasks.end()
        );
        xSemaphoreGiveRecursive(lock);
    }
}

3. 优化任务循环的调度行为 #

用vTaskDelayUntil替代delay，实现固定周期调度，让FreeRTOS更稳定地分配CPU时间：

static void taskUpdateHandler(void *parameter)
{
    TasksQueue *instance = static_cast<TasksQueue *>(parameter);
    Serial.println(F("Tasks queue running"));
    
    TickType_t lastWakeTime = xTaskGetTickCount();
    const TickType_t interval = pdMS_TO_TICKS(1); // 固定1ms周期

    while (true)
    {
        instance->processPendingTasks();
        instance->removeCompletedTasks();
        // 确保任务按固定周期执行，主动让渡CPU
        vTaskDelayUntil(&lastWakeTime, interval);
    }
    Serial.println(F("Tasks queue stopped"));
}

4. 调整任务优先级 #

避免TasksQueue任务优先级过高或过低，建议设为比Arduino默认loop任务（优先级1）略高的数值：

void start(BaseType_t coreId = 1 - ARDUINO_RUNNING_CORE)
{
    // 优先级设为2，平衡调度优先级
    xTaskCreateUniversal(taskUpdateHandler, "tasks queue", getArduinoLoopTaskStackSize(), 
                        this, 2, NULL, coreId);
}

5. 检查Task子类实现 #

确保TemperatureRequestTask的start()和update()函数没有死循环、内存泄漏或非法内存访问：

• update()必须正确返回任务完成状态，不能长时间阻塞；
• 如果需要阻塞操作，应该在Task内部创建子任务或使用FreeRTOS的vTaskDelay。

1. 先测试无跨核心debug任务的场景，确认TasksQueue自身循环稳定；
2. 再添加跨核心debug任务，验证跨核心入队的稳定性；
3. 移除临时的Serial.println或大延迟，确认修复后的代码无需临时措施也能稳定运行。

内容的提问来源于stack exchange，提问作者SagiZiv