C 语言工业级通用组件手写 13：事件队列

前言：

在传统线性裸机代码中，业务逻辑层层嵌套、标志位泛滥、状态耦合严重，新增功能极易引发连锁 BUG。事件驱动架构依靠事件队列统一接收各类消息，按顺序分发处理，实现生产与消费解耦，是大型工业固件标准化开发方案。

网上多数事件队列实现简陋，缺少事件 ID 校验、参数安全传递、溢出保护；本篇实现轻量化通用事件队列，支持静态内存分配、不定长参数传递、防丢失策略，适配裸机与轻量级 RTOS 环境。

一、事件队列核心本质与应用场景

1. 什么是事件队列

事件队列本质是面向消息的 FIFO 容器。

中断、定时器、外设、上层业务产生事件消息并投递入队；主循环持续读取队列，依次执行对应事件处理函数。

核心思想：生产者产生事件、消费者统一处理事件。

2. 解决的核心痛点

• 解决标志位泛滥问题：消除大量全局 flag，逻辑更加规整。
• 解决中断内执行复杂业务：中断仅投递事件，耗时业务放到主循环运行，缩短中断耗时。
• 解决业务耦合：模块之间不直接调用函数，依靠事件通信，模块高度解耦。
• 解决任务无序执行：事件先进先出，避免抢占乱序引发逻辑异常。
• 解决新增功能改旧代码：新增事件仅需要增加事件 ID 与处理函数，不改动原有流程。

3. 典型工业级落地场景

• 外设中断事件：按键触发、串口接收完成、传感器数据就绪。
• 定时事件：定时上报、周期巡检、超时告警。
• 指令事件：上位机下发命令、本地按键操作指令。
• 异常事件：故障触发、保护动作、设备离线通知。 多
• 模块通信：采集模块、通讯模块、控制模块消息交互。

二、核心实现原理

1. 消息封装

每条事件包含：事件 ID + 参数长度 + 参数缓冲区。

支持携带自定义参数，满足事件附带数据的场景。

2. FIFO 存储机制

底层依托缓冲区实现环形存储；事件投递为生产者，主循环轮询读取为消费者。

中断投递、主循环读取属于单生产单消费模型，天然无锁。

3. 事件分发策略

读取事件后根据事件 ID 匹配对应的处理回调，完成消息分发。

三、工业级设计规范

1. 封装性设计

事件结构体完全封装，对外仅暴露投递、读取、初始化接口；内部缓冲区不可直接操作。

2. 接口设计原则

3. 鲁棒性要求

空指针校验、参数长度边界限制；队列满时支持丢弃策略；防止参数缓冲区越界；支持静态内存，无需 malloc。

4. 线程安全约束

中断投递 + 主循环读取：单生产者单消费者，无需加锁。

多中断 / 多线程同时投递事件时，需要关闭中断或者增加互斥锁保护。

四、完整可复用源码

1. 头文件 event_queue.h

#ifndef EVENT_QUEUE_H #define EVENT_QUEUE_H #include <stdint.h> #include <stdbool.h> #include <stddef.h> #ifdef __cplusplus extern "C" { #endif // 单条事件最大携带参数长度，可根据工程修改 #define EVENT_ARG_MAX_LEN 16 // 事件结构体 typedef struct { uint16_t event_id; uint8_t arg_len; uint8_t arg[EVENT_ARG_MAX_LEN]; } event_msg_t; // 事件队列句柄 typedef struct { event_msg_t *msg_buf; uint16_t buf_max; uint16_t w_ptr; uint16_t r_ptr; } event_queue_t; /** * @brief 初始化事件队列 * @param queue 队列句柄 * @param msg_buf 静态消息缓冲区 * @param max_msg 最大容纳事件条数 */ void event_queue_init(event_queue_t *queue, event_msg_t *msg_buf, uint16_t max_msg); /** * @brief 投递带参数事件 * @return true投递成功，false队列已满 */ bool event_queue_post(event_queue_t *queue, uint16_t event_id, const uint8_t *arg, uint8_t arg_len); /** * @brief 投递无参数简易事件 */ static inline bool event_queue_post_simple(event_queue_t *queue, uint16_t event_id) { return event_queue_post(queue, event_id, NULL, 0); } /** * @brief 获取队首事件（只读，不弹出） * @return true存在事件 */ bool event_queue_get(event_queue_t *queue, event_msg_t *msg); /** * @brief 弹出队首事件（处理完成后调用） */ void event_queue_pop(event_queue_t *queue); /** * @brief 获取当前队列存在事件数量 */ uint16_t event_queue_get_used(event_queue_t *queue); #ifdef __cplusplus } #endif #endif

2. 实现文件 event_queue.c

#include "event_queue.h" #include <string.h> void event_queue_init(event_queue_t *queue, event_msg_t *msg_buf, uint16_t max_msg) { if (queue == NULL || msg_buf == NULL || max_msg == 0) { return; } queue->msg_buf = msg_buf; queue->buf_max = max_msg; queue->w_ptr = 0; queue->r_ptr = 0; } bool event_queue_post(event_queue_t *queue, uint16_t event_id, const uint8_t *arg, uint8_t arg_len) { if (queue == NULL) { return false; } uint16_t used = event_queue_get_used(queue); if (used >= queue->buf_max) { return false; } event_msg_t *p_msg = &queue->msg_buf[queue->w_ptr]; p_msg->event_id = event_id; p_msg->arg_len = (arg_len > EVENT_ARG_MAX_LEN) ? EVENT_ARG_MAX_LEN : arg_len; if (arg != NULL && p_msg->arg_len > 0) { memcpy(p_msg->arg, arg, p_msg->arg_len); } queue->w_ptr = (queue->w_ptr + 1) % queue->buf_max; return true; } bool event_queue_get(event_queue_t *queue, event_msg_t *msg) { if (queue == NULL || msg == NULL) { return false; } if (queue->r_ptr == queue->w_ptr) { return false; } memcpy(msg, &queue->msg_buf[queue->r_ptr], sizeof(event_msg_t)); return true; } void event_queue_pop(event_queue_t *queue) { if (queue == NULL) { return; } if (queue->r_ptr != queue->w_ptr) { queue->r_ptr = (queue->r_ptr + 1) % queue->buf_max; } } uint16_t event_queue_get_used(event_queue_t *queue) { if (queue == NULL) { return 0; } int16_t diff = (int16_t)(queue->w_ptr - queue->r_ptr); if (diff < 0) { diff += queue->buf_max; } return (uint16_t)diff; }

五、实战演示：事件调度示例

#include <stdio.h> #include "event_queue.h" // 定义事件ID #define EVENT_KEY_DOWN 0x0001 #define EVENT_UART_RECV 0x0002 #define EVENT_TIMER_ALARM 0x0003 #define EVENT_BUF_NUM 8 event_msg_t event_buf[EVENT_BUF_NUM]; event_queue_t sys_event_queue; // 事件处理分发函数 void event_dispatch(event_msg_t *msg) { switch (msg->event_id) { case EVENT_KEY_DOWN: printf("按键按下事件\n"); break; case EVENT_UART_RECV: printf("串口收到数据, len:%d\n", msg->arg_len); break; case EVENT_TIMER_ALARM: printf("定时告警事件\n"); break; default: printf("未知事件ID:%d\n", msg->event_id); break; } } int main(void) { event_queue_init(&sys_event_queue, event_buf, EVENT_BUF_NUM); // 模拟中断投递事件 event_queue_post_simple(&sys_event_queue, EVENT_KEY_DOWN); event_queue_post_simple(&sys_event_queue, EVENT_TIMER_ALARM); event_msg_t curr_msg; // 主循环事件调度 while (1) { if (event_queue_get(&sys_event_queue, &curr_msg)) { event_dispatch(&curr_msg); event_queue_pop(&sys_event_queue); } } }

运行效果：事件按投递顺序依次处理；队列满自动拒绝新增消息；支持携带参数传递业务数据。

六、工业级进阶优化方向

1. 支持事件优先级队列

拆分普通队列 + 高优先级紧急事件队列，紧急消息优先响应。

2. 队列满策略扩展

支持覆盖旧事件、丢弃新事件两种模式可选。

3. 事件订阅机制

结合双向链表实现订阅者模式，一条事件通知多个模块。

4. 增加事件监控统计

统计丢包数量、队列峰值，方便调试系统负载。

七、高频面试考点与易错坑点

1. 经典面试问答

Q1：为什么中断里不能执行复杂业务？

答：中断优先级高，长时间占用会屏蔽其他中断，导致外设丢数据；标准方案为中断仅投递事件，复杂逻辑放到主循环处理。

Q2：事件队列和普通 FIFO 环形缓冲区区别？

答：普通 FIFO 面向原始字节流；事件队列封装完整消息结构，自带 ID 与参数，面向业务消息通信。

Q3：单中断投递事件是否需要关中断保护队列？

答：单个中断 + 主循环读取无需关中断；多个中断同时投递事件必须关中断保护读写指针。

Q4：事件驱动架构优势？

答：模块解耦、逻辑清晰、方便扩展、降低嵌套层级，非常适合中长期维护的工业固件。

2. 常见易错坑点

• 中断与主循环并发操作队列不加保护，引发指针错乱；
• 参数长度超出最大缓存，造成内存越界；
• 读取事件后忘记调用 pop，导致重复处理同一消息；
• 无限投递不消费，队列持续占满，新事件直接丢失。

总结

事件队列是搭建事件驱动裸机框架的核心组件，是中小型嵌入式项目从杂乱轮询架构升级标准化架构的关键。

依靠事件队列，能够彻底清理全局标志位、隔离中断与业务代码，让固件可读性、可维护性大幅提升，可直接落地工业产品。

创作不易，如果对你有帮助，欢迎点赞、收藏、转发。