多线程嵌入式软件原子操作问题：RTOS下状态机变量读写及共享资源访问

嘿，这可是RTOS嵌入式开发里的经典坑啊！我之前做工业控制项目的时候也碰到过类似的多线程读写共享状态变量的问题，尤其是状态机这种对时序和状态一致性要求很高的场景，稍不注意就会出现诡异的状态跳变或者读取到陈旧值。结合你给出的代码，给你几个针对性的解决方案：

1. 原子操作+Volatile（轻量简单方案） #

你的state_e是枚举类型，本质是和处理器字长一致的整数（大部分ARM/RISC-V平台是32位），这类单字变量的读写在硬件层面是原子的——不会出现读/写到一半被线程打断的情况。但要注意编译器优化导致的可见性问题：编译器可能会把currState缓存到寄存器里，导致其他线程看不到最新的赋值结果。

所以第一步先给状态变量加上volatile限定符，强制编译器每次从内存读取变量：

typedef struct{
    volatile state_e currState; // Volatile保证变量可见性，禁止寄存器缓存
}StateMachine;

然后实现线程安全的读写函数：

state_e GetState(StateMachine* sm)
{
    // 单字原子读取，直接返回即可
    return sm->currState;
}

void SetState(StateMachine* sm, state_e newState)
{
    // 单字原子赋值
    sm->currState = newState;
}

注意：这个方案只适用于单字大小的状态变量，且你的处理器支持单字原子操作。如果未来状态机要扩展成多变量组合的状态，这个方法就不适用了。

2. RTOS互斥锁（通用严谨方案） #

如果你的状态机后续可能扩展，或者想确保绝对的线程安全，最稳妥的方式是用RTOS提供的**互斥锁（Mutex）**来保护对状态机的所有访问。互斥锁能保证同一时间只有一个线程能操作状态变量，彻底避免竞争条件。

首先修改结构体，加入互斥锁句柄：

#include "your_rtos_header.h" // 替换成你实际使用的RTOS头文件，比如FreeRTOS的FreeRTOS.h

typedef struct{
    state_e currState;
    SemaphoreHandle_t stateMutex; // 互斥锁句柄，用于保护状态变量
}StateMachine;

初始化状态机的时候要创建互斥锁（记得处理创建失败的情况，嵌入式系统里错误处理很重要）：

StateMachine g_sm; // 全局状态机实例

void StateMachine_Init(void)
{
    g_sm.currState = STATE_01;
    g_sm.stateMutex = xSemaphoreCreateMutex();
    
    // 检查互斥锁是否创建成功，失败则进入错误处理
    if(g_sm.stateMutex == NULL)
    {
        // 这里可以加断言、日志或者系统复位逻辑
        while(1);
    }
}

接着实现线程安全的读写函数：

state_e GetState(StateMachine* sm)
{
    state_e currentState = STATE_01;
    // 获取互斥锁，portMAX_DELAY表示一直等待直到获取成功
    if(xSemaphoreTake(sm->stateMutex, portMAX_DELAY) == pdTRUE)
    {
        currentState = sm->currState;
        xSemaphoreGive(sm->stateMutex); // 释放互斥锁
    }
    return currentState;
}

void SetState(StateMachine* sm, state_e newState)
{
    if(xSemaphoreTake(sm->stateMutex, portMAX_DELAY) == pdTRUE)
    {
        sm->currState = newState;
        xSemaphoreGive(sm->stateMutex);
    }
}

这个方案的好处是通用且绝对安全，不管状态机怎么扩展，只要所有访问都通过互斥锁保护，就不会出现线程竞争问题。唯一的小缺点是有一点点性能开销，但在嵌入式系统里这种开销几乎可以忽略不计。

3. 临界区（极端性能敏感场景） #

如果你的状态变量读写频率极高，不想承担互斥锁的开销，可以用RTOS的临界区机制——也就是在读写时禁用中断，防止线程切换（因为RTOS的调度通常是基于中断的）。

实现方式如下：

#include "your_rtos_header.h"

state_e GetState(StateMachine* sm)
{
    state_e currentState;
    // 进入临界区，保存当前中断状态
    UBaseType_t savedIntStatus = taskENTER_CRITICAL_FROM_ISR();
    currentState = sm->currState;
    taskEXIT_CRITICAL_FROM_ISR(savedIntStatus); // 退出临界区，恢复中断状态
    return currentState;
}

void SetState(StateMachine* sm, state_e newState)
{
    UBaseType_t savedIntStatus = taskENTER_CRITICAL_FROM_ISR();
    sm->currState = newState;
    taskEXIT_CRITICAL_FROM_ISR(savedIntStatus);
}

注意：临界区的代码要尽量短，绝对不能在里面做耗时操作（比如延时、IO读写），否则会严重影响系统的实时性。这个方案只适合简单的单变量读写场景。

额外提醒：中断里调用的注意事项 #

如果你的SetState需要在中断服务函数（ISR）里调用，那普通互斥锁就不能用了（ISR里不能调用xSemaphoreTake，会导致死锁）。这时候优先选择原子操作+Volatile或者临界区方案，如果一定要用同步机制，可以用RTOS的二值信号量（但要注意信号量的使用方式）。

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