ThreadX嵌入式多线程系统中如何按需快速退出告警播放函数

我正在开发一款多线程应用，其中一个线程负责处理告警系统，会根据告警场景播放特定的告警音序列。另有一个功能可通过其他线程设置标志位来静音告警。当告警被静音时，我希望程序立即停止告警播放，不再执行完整序列。

以下是代码结构示例：

static int mute = 0;
static int current_alarm = 0;

void play_alarm_2 (void)
{
play_g_tone();
sleep(30);
play_a_tone();
sleep(20);
...
} 

void play_alarm_1 (void)
{
play_c_tone();
sleep(10);
play_f_tone();
sleep(20);
...
} 

void set_mute_status (int mute_status)
{
mute = mute_status;
}
void set_current_alarm (int alarm)
{
current_alarm = alarm;
}

int main()
{
    for(;;)
    {
    switch(current_alarm)
        case 1:
            play_alarm_1();
        case 2:
            play_alarm_2();
        ...
    }
}

其他线程负责设置告警场景和静音选项。例如，当告警线程正在执行play_alarm_2并播放g音时，若用户触发静音，我希望在g音播放完成后退出play_alarm_2函数，无需中断当前音。目前的笨方法是在每行操作后添加检查：

void play_alarm_2 (void)
{
if (mute)
    return

play_g_tone();

if (mute)
    return

sleep(30);

if (mute)
    return

play_a_tone();

if (mute)
    return

sleep(20);
...
} 

该方法虽能解决问题但不够优雅，也可通过宏实现。我想了解是否有更规范的实现方式？可能需要引入新线程，但我希望尽量避免。若必须使用新线程，正确的实现方式是什么？

注：该代码将运行在嵌入式系统中，使用ThreadX。

方案一：封装检查逻辑为宏（优雅化现有思路） #

这是嵌入式场景下实用的轻量化方案，用宏封装重复的静音检查逻辑，既减少代码冗余，又保持可读性：

#define CHECK_MUTE() do { if (mute) return; } while(0)

void play_alarm_2 (void)
{
    CHECK_MUTE();
    play_g_tone();
    
    CHECK_MUTE();
    sleep(30);
    
    CHECK_MUTE();
    play_a_tone();
    
    CHECK_MUTE();
    sleep(20);
    ...
}

do-while(0)是嵌入式C宏定义的标准写法，能避免宏在条件语句中使用时出现语法错误。

方案二：重构为状态机架构（高可维护性） #

如果告警序列较长，状态机模式更易扩展和维护，同时自然嵌入静音检查：

typedef enum {
    ALARM_2_IDLE,
    ALARM_2_PLAY_G,
    ALARM_2_WAIT_G,
    ALARM_2_PLAY_A,
    ALARM_2_WAIT_A,
    // 其他状态...
} Alarm2State;

static Alarm2State alarm2_state = ALARM_2_IDLE;

void play_alarm_2_step(void)
{
    if (mute) {
        alarm2_state = ALARM_2_IDLE;
        return;
    }
    
    switch(alarm2_state) {
        case ALARM_2_IDLE:
            alarm2_state = ALARM_2_PLAY_G;
            break;
        case ALARM_2_PLAY_G:
            play_g_tone();
            alarm2_state = ALARM_2_WAIT_G;
            break;
        case ALARM_2_WAIT_G:
            static ULONG wait_count = 0;
            if (wait_count < 30) {
                tx_thread_sleep(1); // 替换为ThreadX的短延时，适配系统tick单位
                wait_count++;
            } else {
                wait_count = 0;
                alarm2_state = ALARM_2_PLAY_A;
            }
            break;
        case ALARM_2_PLAY_A:
            play_a_tone();
            alarm2_state = ALARM_2_WAIT_A;
            break;
        case ALARM_2_WAIT_A:
            static ULONG wait_a_count = 0;
            if (wait_a_count < 20) {
                tx_thread_sleep(1);
                wait_a_count++;
            } else {
                wait_a_count = 0;
                alarm2_state = ALARM_2_IDLE;
            }
            break;
        // 处理其他状态...
    }
}

// 主循环修改为分步执行
int main()
{
    for(;;)
    {
        switch(current_alarm) {
            case 1:
                play_alarm_1_step();
                break;
            case 2:
                play_alarm_2_step();
                break;
            // 其他告警分支...
        }
        tx_thread_sleep(1); // 给其他线程调度机会
    }
}

这种方式的优势：

• 每步执行后都能检查静音状态，不会长时间阻塞线程
• 状态机模式便于新增/修改告警序列，维护成本低
• 适配ThreadX的线程调度模型，保证系统响应性

方案三：利用ThreadX事件标志组（高效无冗余） #

用ThreadX原生的事件标志替代全局mute变量，在等待过程中同时监听静音事件，无需手动循环检查：

1. 初始化事件标志组：

TX_EVENT_FLAGS_GROUP alarm_event_flags;
#define MUTE_FLAG 0x01

// 在系统初始化时执行
tx_event_flags_create(&alarm_event_flags, "Alarm Event Flags");

2. 修改静音设置函数：

void set_mute_status(int mute_status)
{
    if (mute_status) {
        tx_event_flags_set(&alarm_event_flags, MUTE_FLAG, TX_OR);
    } else {
        tx_event_flags_clear(&alarm_event_flags, MUTE_FLAG);
    }
}

3. 修改告警播放函数：

void play_alarm_2(void)
{
    ULONG actual_flags;
    UINT status;
    
    // 预检查静音状态
    status = tx_event_flags_get(&alarm_event_flags, MUTE_FLAG, TX_OR_CLEAR, &actual_flags, TX_NO_WAIT);
    if (status == TX_SUCCESS && (actual_flags & MUTE_FLAG)) {
        return;
    }
    
    play_g_tone();
    
    // 等待30个tick，同时监听静音标志
    status = tx_event_flags_get(&alarm_event_flags, MUTE_FLAG, TX_OR_CLEAR, &actual_flags, 30);
    if (status == TX_SUCCESS && (actual_flags & MUTE_FLAG)) {
        return;
    }
    
    play_a_tone();
    
    // 等待20个tick，同时监听静音标志
    status = tx_event_flags_get(&alarm_event_flags, MUTE_FLAG, TX_OR_CLEAR, &actual_flags, 20);
    if (status == TX_SUCCESS && (actual_flags & MUTE_FLAG)) {
        return;
    }
    
    // 后续步骤...
}

该方案利用RTOS原生机制，比手动检查更高效，且无需新增线程。

若必须新增线程的实现方式 #

如果业务需要拆分告警播放逻辑到独立线程，可按以下方式实现：

1. 创建告警播放线程：

TX_THREAD alarm_play_thread;
#define ALARM_TRIGGER_FLAG 0x02

void alarm_play_thread_entry(ULONG thread_input)
{
    ULONG actual_flags;
    UINT status;
    
    for(;;) {
        // 等待告警触发或静音事件
        status = tx_event_flags_get(&alarm_event_flags, ALARM_TRIGGER_FLAG | MUTE_FLAG, TX_OR_CLEAR, &actual_flags, TX_WAIT_FOREVER);
        if (status != TX_SUCCESS) {
            continue;
        }
        
        // 若收到静音事件，直接回到等待状态
        if (actual_flags & MUTE_FLAG) {
            continue;
        }
        
        // 根据当前告警类型播放序列
        switch(current_alarm) {
            case 1:
                play_alarm_1_with_check(); // 内部包含静音检查逻辑
                break;
            case 2:
                play_alarm_2_with_check();
                break;
            // 其他告警分支...
        }
    }
}

2. 修改告警触发函数：

void set_current_alarm(int alarm)
{
    current_alarm = alarm;
    tx_event_flags_set(&alarm_event_flags, ALARM_TRIGGER_FLAG, TX_OR);
}

这种方式实现了职责分离，主线程负责触发告警和设置静音，播放线程专注于处理播放与中断逻辑，符合多线程设计规范。

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