一、简介
QT 中有一种异步处理机制叫做信号和槽函数，通过将信号与槽函数进行绑定连接，后续若该信号触发，会自动调用对应的槽函数。这种机制很适合处理很繁琐的逻辑程序，例如我点击界面的 close 按钮，便触发 close 信号，自动调用 close 绑定的槽函数，关闭界面。这种使用流程简便快捷。这种处理机制可称作异步处理，C 语言中也有一些异步处理开源的库，例如 libevent、libev 等，前者功能丰富，技术框架较为成熟，在许多项目中都见到它身影。这些开源库成熟，但是也庞大，能不能搞一个简洁的异步事件库呢？接下来我们就实现一个简单异步事件处理。
二、设计实现
我做的是一个简单异步事件，根据信号触发对应事件，实现原理很简单：
1.绑定信号和对应的回调函数;
2.检测信号队列或者链表，若有信号触发，便取出链表中的节点处理对应的回调函数。
本设计中采用是双向链表存储信号，为了方便（偷懒），就不自己造链表的轮子了，这里使用 Linux 内核源码中的双向链表(list.h)。
完整代码：
#include
#include
#include
#include
#include
#include
#define USE_MUTI_THREAD 1
struct list_head {
struct list_head *next, *prev;
};
//这个eventinfo_t结构体里面包含对应的信号值和函数指针。
typedef struct eventinfo_t
{
void (*func)(void* args); /* 事件回调函数 */
int sig; /* 信号值 */
}eventinfo_t;
//这个eventlist_t结构体是定义信号链表的，里面包含了触发信号时候传递的参数，信号值，一个链表。
typedef struct eventlist_t
{
void *args; /* 传递的参数 */
int sig; /* 信号值 */
struct list_head list; /* 双向链表 */
}eventlist_t;
//这个asyncevent_t结构体是异步事件处理句柄定义，包含所有信息。
typedef struct asyncevent_t
{
struct list_head hlist; /* 信号链表头 */
eventinfo_t map[1024]; /* 信号与函数映射 */
#if USE_MUTI_THREAD /* 是否使用多线程 */
pthread_mutex_t lock; /* 互斥锁 */
pthread_cond_t cond; /* 条件变量 */
#endif
}asyncevent_t;
#define list_entry(ptr, type, member) \
(type *)( (char *)ptr - ((size_t) &((type *)0)->member))
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
#define list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}
static inline void __list_add(struct list_head *new_node, struct list_head *prev, struct list_head *next)
{
next->prev = new_node;
new_node->next = next;
new_node->prev = prev;
prev->next = new_node;
}
static inline void list_add(struct list_head *new_node, struct list_head *head)
{
__list_add(new_node, head, head->next);
}
static inline void list_add_tail(struct list_head *new_node, struct list_head *head)
{
new_node->next = head;
new_node->prev = head->prev;
head->prev->next = new_node;
head->prev = new_node;
}
static inline void list_del(struct list_head *entry)
{
entry->next->prev = entry->prev;
entry->prev->next = entry->next;
entry->next = NULL;
entry->prev = NULL;
}
static inline int list_empty(const struct list_head *head)
{
return head->next == head;
}
//定义的函数
/**
* @brief: 异步事件绑定信号和回调函数
* @handle: 事件句柄
* @sig: 信号值
* @func: 处理该信号的函数
* @return: 0:成功
*/
int async_event_bind(asyncevent_t* handle, int sig, void (*func)(void* args))//绑定信号和函数
{
if(!handle || !func) return -1; /* 句柄不存在 */
if(sig<0 || sig>1024) return -2; /* 信号值超过有效范围 */
if(handle->map[sig].func) return -3;/* 信号以及被绑定过了 */
handle->map[sig].func = func; /* 绑定函数 */
handle->map[sig].sig = sig; /* 绑定信号 */
return 0;
}
/**
* @brief: 发射信号，触发事件
* @priority: 0:添加到链表尾部 非0:添加到链表头部(能及时响应)
* @sig: 对应的信号
* @args: 传递的参数
* @return: 0:成功
*/
int async_event_emit(asyncevent_t* handle, int priority, int sig, void* args)
{
if(!handle) return -1; /* 事件句柄不存在 */
if(sig<0 || sig>1024) return -2; /* 信号值超过有效范围 */
if(!handle->map[sig].func) return -3; /* 该信号未绑定,不能触发事件 */
eventlist_t* node = (eventlist_t*)malloc(sizeof(eventlist_t));
if(!node) return -1;
node->args = args;
node->sig = sig;
#if USE_MUTI_THREAD
pthread_mutex_lock(&handle->lock);
#endif
if(priority)
list_add(&node->list, &handle->hlist); /* 往头部添加 */
else
list_add_tail(&node->list, &handle->hlist); /* 往尾部添加 */
#if USE_MUTI_THREAD
pthread_cond_signal(&handle->cond);
pthread_mutex_unlock(&handle->lock);
#endif
return 0;
}
/**
* @brief: 调度处理所有的事件任务
* @handle: 事件句柄
* @return: 0:成功
*/
int async_event_process(asyncevent_t* handle) //调度处理
{
if(!handle) return -1;
struct list_head *pos, *n;
eventlist_t *node;
int sig = 0;
#if USE_MUTI_THREAD
pthread_mutex_lock(&handle->lock);
while (list_empty(&handle->hlist)){
pthread_cond_wait(&handle->cond, &handle->lock);
}
pthread_mutex_unlock(&handle->lock);
#endif
list_for_each_safe(pos, n, &handle->hlist){
node = list_entry(pos, eventlist_t, list);
#if USE_MUTI_THREAD
pthread_mutex_lock(&handle->lock);
list_del(&node->list); /* 从链表中删除节点 */
pthread_mutex_unlock(&handle->lock);
#else
list_del(&node->list); /* 从链表中删除节点 */
#endif
sig = node->sig;
handle->map[sig].func(node->args); /* 调用事件函数 */
free(node);
}
return 0;
}
/**
* @brief: 创建一个异步事件处理句柄
* @return：异步事件句柄
*/
asyncevent_t* create_async_event(void)
{
asyncevent_t *handle = (asyncevent_t*)malloc(sizeof(asyncevent_t));
if(!handle) return NULL;
memset(handle, 0, sizeof(*handle));
INIT_LIST_HEAD(&handle->hlist);
#if USE_MUTI_THREAD
pthread_mutex_init(&handle->lock, NULL);
pthread_cond_init(&handle->cond, NULL);
#endif
return handle;
}
/**
* @brief: 释放异步事件资源
* @return: 0:成功
*/
int async_event_destory(asyncevent_t* handle)
{
if(!handle) return -1;
struct list_head *pos, *n;
eventlist_t *node;
#if USE_MUTI_THREAD
pthread_mutex_lock(&handle->lock);
#endif
list_for_each_safe(pos, n, &handle->hlist){
node = list_entry(pos, eventlist_t, list);
list_del(&node->list); /* 从链表中删除节点 */
free(node);
}
#if USE_MUTI_THREAD
pthread_mutex_unlock(&handle->lock);
pthread_mutex_destroy(&handle->lock);
pthread_cond_destroy(&handle->cond);
#endif
free(handle);
return 0;
}
#if 0//use process
使用流程
通过修改 文件中#define USE_MUTI_THREAD 1 的宏定义决定是否使用多线程，为 1 使用多线程。
a.单线程模式测试
首先定义枚举类型的信号(也可不定义,直接写数值,为了规范还是建议定义)，编写对应的事件处理函数如void event_click_func(void *args)，然后创建句柄，绑定信号，在 while 循环里面调用async_event_process(handle);处理函数，至于信号什么时候发射完全由外部决定，本例直接在循环里面一直发射信号。注：不能在自己信号处理函数中发射自己信号，这样会导致一直循环发射处理，造成死循环，但是可以发射除自身以外的其他信号。
#endif
enum SIG_TYPE //信号类型
{
CLICK=1, //单击
MOVE, //拖动
PRESS, //按下
RELEASE, //释放
};
asyncevent_t* handle;
void event_click_func(void *args)
{
printf("Click Event Trigger, Times=%d...\n", *(int*)args);
//可以在事件处理函数中触发其他的信号！
//不能在自己事件函数中触发自己，这样会一直循环触发自己，造成死循环!
// async_event_emit(handle, 1, CLICK, args); //错误
async_event_emit(handle, 1, MOVE, args);
async_event_emit(handle, 1, PRESS, args);
async_event_emit(handle, 1, RELEASE, args);
}
void event_move_func(void* args)
{
printf("Move Event Trigger, Times=%d...\n", *(int*)args);
}
void event_press_func(void *args)
{
printf("Press Event Trigger, Times=%d...\n", *(int*)args);
}
void event_release_func(void *args)
{
printf("Release Event Trigger, Times=%d...\n", *(int*)args);
}
#if USE_MUTI_THREAD == 0
int main(int argc, char **argv)
{
int cnt = 0;
//1.创建事件句柄
handle = create_async_event();
//2.绑定信号
async_event_bind(handle, CLICK, event_click_func);
async_event_bind(handle, MOVE, event_move_func);
async_event_bind(handle, PRESS, event_press_func);
async_event_bind(handle, RELEASE, event_release_func);
//3.循环调度执行
while(1)
{
async_event_process(handle);
async_event_emit(handle, 0, CLICK, &cnt);
}
return 0;
}
#else
#if 0//use process
b.多线程模式测试
处理 main 函数与上面不同，其他定义是一样的。本例使用多线程测试，开启一个线程一直调用async_event_process(handle)处理函数，然后 main 函数中采用输入 a-c 字符触发信号。
#endif
void* process_event_thread(void *args)
{
asyncevent_t* handle = (asyncevent_t*)args;
//循环调度执行
while(1)
{
async_event_process(handle);
}
}
int main(int argc, char** argv)
{
pthread_t th;
char c=0;
int cnt_click = 0, cnt_move=0, cnt_press=0, cnt_release=0;
//1.创建事件句柄
handle = create_async_event();
//2.绑定信号
async_event_bind(handle, CLICK, event_click_func);
async_event_bind(handle, MOVE, event_move_func);
async_event_bind(handle, PRESS, event_press_func);
async_event_bind(handle, RELEASE, event_release_func);
//3.创建一个线程去处理事件
pthread_create(&th, NULL, process_event_thread, handle);
while(1)
{
//4.根据自己时机去触发信号
scanf("%c", &c);
switch (c)
{
case 'a':
cnt_click++;
async_event_emit(handle, 0, CLICK, &cnt_click);
break;
case 'b':
cnt_move++;
async_event_emit(handle, 0, MOVE, &cnt_move);
break;
case 'c':
cnt_press++;
async_event_emit(handle, 0, PRESS, &cnt_press);
break;
case 'd':
cnt_release++;
async_event_emit(handle, 0, RELEASE, &cnt_release);
break;
default:
break;
}
}
pthread_join(th, NULL);
return 0;
}
#endif
#if 0//use process
输入a,先触发click信号，然后在click处理函数中发射release、press、move等信号，继续触发对应的处理函数。输入b单独触发move信号，输入c单独触发press信号，输入d单独触发release信号。
#endif
三、使用说明
1.编译运行
执行编译命令：g++ xxx.cpp -o test -lpthread
运行结果：./test
2.使用方法
通过修改文件中#define USE_MUTI_THREAD 1 的宏定义决定是否使用多线程，为 1 使用多线程。
异步事件处理程序还不够完善，欢迎大家尝试运行一下。
参考地址：一百多行 C 语言代码实现一个简单异步事件触发机制! - 知乎 (zhihu.com)