如何在未完成上一条命令时接收并处理新命令？（消息队列场景）

你的核心问题在于单线程模型下，执行长时间任务时会阻塞命令接收，导致stop命令无法被及时处理。用线程实现是完全可行的，也是这类场景的标准解决方案。

原代码的核心问题 #

当前代码是单线程执行：当收到start进入flash循环后，主线程被卡在循环里，根本无法调用mq_receive去接收后续的stop命令，自然做不到实时响应。必须把命令接收和任务执行拆分成两个独立的执行流。

基于线程的实现方案 #

我们可以把flash任务放到独立线程中运行，主线程专注于消息队列的命令监听，通过线程安全的标志来控制任务的启停：

关键要点 #

• 使用原子布尔类型（std::atomic<bool>）来定义控制标志，避免多线程下的数据竞争。
• 主线程负责接收命令，根据命令设置标志或启动/停止线程。
• flash线程定期检查停止标志，一旦触发就退出循环。

修改后的完整代码示例 #

#include <iostream>
#include <string>
#include <thread>
#include <atomic>
#include <memory>
#include <chrono>

// 线程安全的控制标志
std::atomic<bool> stop_flag(false);
std::atomic<bool> is_flashing(false);
std::unique_ptr<std::thread> flash_thread;

// flash任务的执行函数
void flash_task() {
    stop_flag = false;
    std::cout << "[programming] Start install Processing" << std::endl;
    
    // 模拟约1分钟的循环操作，替换为实际flash逻辑即可
    int loop_count = 0;
    while (loop_count < 6000) { // 假设单次循环10ms，6000次对应1分钟
        // 执行flash操作的单次步骤
        // do flash....
        
        // 检查停止标志，触发则退出
        if (stop_flag.load()) {
            std::cout << "[programming] Flash stopped by command" << std::endl;
            break;
        }
        
        loop_count++;
        // 短延时避免CPU占用过高
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    is_flashing = false;
    std::cout << "[programming] Flash process finished" << std::endl;
}

int main() {
    int rmqID; // 假设已完成消息队列ID初始化
    char rbuff[256];
    int rc;

    while (true) {
        rc = mq_receive(rmqID, rbuff, sizeof(rbuff), 0);
        if (rc < 0) {
            std::cout << "receive timeout !!" << std::endl;
        } else {
            std::cout << "receive message : " << rbuff << std::endl;
            std::string cmd = rbuff;
            
            if (cmd == "start") {           
                std::cout << "[receive message] start command received" << std::endl;
                // 无正在执行的任务时启动新线程
                if (!is_flashing.load()) {
                    is_flashing = true;
                    flash_thread = std::make_unique<std::thread>(flash_task);
                } else {
                    std::cout << "[receive message] Flash is already running, ignore start command" << std::endl;
                }
            } else if (cmd == "stop") {           
                std::cout << "[receive message] stop command received" << std::endl;
                stop_flag = true;
                // 可选：等待线程退出，确保资源正确释放
                if (flash_thread && flash_thread->joinable()) {
                    flash_thread->join();
                    flash_thread.reset();
                }
            } else {
                std::cout << "[receive message] Command error!" << std::endl;
            }
        }
    }

    return 0;
}

代码说明 #

1. 线程安全标志：stop_flag和is_flashing用std::atomic<bool>，保证多线程下读写操作的原子性，避免未定义行为。
2. 任务线程：flash_task独立执行flash逻辑，每次循环都会检查停止标志，收到命令后立即退出。
3. 主线程逻辑：主线程仅负责监听消息队列，收到start时检查任务状态并启动线程；收到stop时设置停止标志，可选等待线程退出。
4. 资源管理：用std::unique_ptr<std::thread>持有线程对象，自动管理资源，避免内存泄漏。

额外注意事项 #

• 若mq_receive是阻塞调用，可设置合理超时，让主线程定期醒来检查状态；也可根据消息队列特性使用信号驱动方式接收消息。
• 多次启停场景下，需确保线程完全退出后再重新启动，避免资源冲突。
• 若flash操作涉及硬件资源，需注意线程安全的资源访问，必要时加锁。

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