C程序设计：基于循环双向链表的事件管理器

CJourneys

已于 2023-07-18 15:08:05 修改

阅读量138

点赞数

分类专栏：从单片机到freertos C/C++ 设计师文章标签：链表数据结构

于 2023-07-05 10:11:11 首次发布

本文链接：https://blog.csdn.net/weixin_42549534/article/details/131549093

版权

C/C++ 设计师同时被 2 个专栏收录

19 篇文章 2 订阅

订阅专栏

从单片机到freertos

17 篇文章 5 订阅

订阅专栏

1.简介

基于循环双向链表的事件管理系统是一种用于管理事件的数据结构。它可以用于多种场景，包括计划任务、调度、日程安排等。

原理如下：

事件节点：每个事件都被表示为一个节点，每个节点包含一些必要的属性，比如事件的名称、开始时间、结束时间等。节点之间通过指针连接形成链表。
循环链表：链表的最后一个节点的下一个节点指针指向链表的第一个节点，形成一个循环链表。这样可以方便地进行遍历和循环操作。
双向链表：除了通常的单向指针外，每个节点还包含一个指向前一个节点的指针。这样可以在链表中高效地进行向前或向后遍历。
插入事件：要插入一个事件节点，首先需要找到插入位置。可以从链表的头部开始遍历，按照时间顺序将事件插入到合适的位置。如果要插入的位置在链表中间，需要调整节点的指针。
删除事件：要删除一个事件节点，需要先找到对应的节点位置，然后将删除节点的前一个节点的指针指向删除节点的后一个节点，同时将删除节点的后一个节点的指针指向删除节点的前一个节点。
遍历事件：可以通过从链表头部开始遍历，按照链表的循环指针进行遍历。可以根据需要选择正向遍历还是反向遍历。
更新事件：要更新一个事件节点的属性，可以先找到对应的节点位置，然后修改节点中的属性即可。

使用循环双向链表的事件管理系统可以高效地插入、删除、更新和遍历事件，并且可以灵活地适应不同的需求。

2.实现步骤

2.1 依赖关系

基于Linux双向链表实现的事件管理系统。

2.2 数据结构设计

定义了几个事件类型（EventType），包括无事件（ET_NONE）、定时器事件（ET_TIMER）、任务事件（ET_TASK）、循环任务事件（ET_LOOPTASK）和数据事件（ET_DATA）。

结构体EventStaus用于保存事件的执行函数、状态参数1和状态参数2。

结构体EventData用于保存事件的数据，包括有效数据长度和数据内容。

结构体EventList是事件的节点，包含事件类型、事件状态、事件数据、是否激活以及链表节点指针。

结构体EventListQueue表示事件列表的队列，包含数量、链表头指针和节点指针。

2.3 接口设计

eventListIint用于初始化事件列表队列。

getEvent_listCnt用于获取队列中事件的数量。

addToEventList用于向事件列表中添加事件。

getFromEventList用于从事件列表中获取事件。

EventQueue_runTask用于执行循环任务事件。

3.头文件

#ifndef _CJ_EVENT_H_
#define _CJ_EVENT_H_

/* 利用linux双向链表完成事件功能 */
#include "list.h"

#define MAX_EVENT_DATA_CNT          1024

typedef enum _EventType
{
	ET_NONE     = 0x00, //无事件
	ET_TIMER    = 0x01, //定时器事件
	ET_TASK     = 0x02, //任务事件
	ET_LOOPTASK = 0x03, //循环任务事件
	ET_DATA     = 0x04, //数据事件
}EventType;

typedef struct _EventStaus
{
    void *fun;      // 执行函数
    int status_1;   // 状态参数1
    int status_2;   // 状态参数2
} EventStaus;

typedef struct _EventData
{
    int len;             //有效数据长度
	unsigned char *data; //数据 最大值为 MAX_EVENT_DATA_CNT
} EventData;

typedef struct _EventList
{
    EventType type;        //事件类型
	EventStaus status;     //事件状态 除去数据事件外都用这个变量
	EventData data;        //事件的数据 当事件类型为数据事件时才有效
	bool isActive;         //是否激活
	struct list_head node; //链表
} EventList;

typedef struct _EventListQueue
{
	int cnt;			        //数量
	struct list_head listHead;  //队列头
	unsigned char *node;        //节点
} EventListQueue;

bool eventListIint(EventListQueue *queue, int cnt);
int getEvent_listCnt(EventListQueue *queue);
bool addToEventList(EventListQueue *queue, EventType type, EventStaus *status, EventData *data);
bool getFromEventList(EventListQueue *queue, EventType *type, EventStaus *status, EventData *data);
void EventQueue_runTask(EventListQueue *queue);

#endif

4.C文件

#include "cjevent.h"
#include <string.h>

/* 初始化队列 */
bool eventListIint(EventListQueue *queue, int cnt)
{
	int oneQueueSize = sizeof(EventList);

	/* 申请节点 */
	queue->node = (unsigned char *)malloc(oneQueueSize * cnt);
	if(queue->node == NULL)
		return false;
	memset(queue->node, 0, oneQueueSize * cnt);

	/* 初始化链表头 */
	memset(&queue->listHead, 0, sizeof(struct list_head));
	INIT_LIST_HEAD(&queue->listHead);

    /* 记录链表节点个数 */
	queue->cnt = cnt;

	return true;
}

/* 获取链表中的数量 */
int getEvent_listCnt(EventListQueue *queue)
{
	int cnt = 0;
	EventList *current = NULL;
	list_for_each_entry_reverse(current, EventList, &queue->listHead, node)
	{
		cnt += 1;
	}
	return cnt;
}

/* 检查链表中是否有空闲节点 */
static bool checkListHaveIdleNodes(EventListQueue *queue, EventList **p_out)
{
	int i;
	EventList *p = (EventList *)queue->node;
	*p_out = NULL;
	for (i = 0; i < queue->cnt; i++)
	{
		*p_out = p + i;
		if (false == (*p_out)->isActive)
		{
			memset((*p_out), 0, sizeof(EventList));
			break;
		}
	}
	if (i == queue->cnt) //没有空间
		return false;

	return true; //有空间
}

/* 向链表中的增加节点 */
bool addToEventList(EventListQueue *queue, EventType type, EventStaus *status, EventData *data)
{
	EventList *lister = NULL;

	if (checkListHaveIdleNodes(queue, &lister) == true)
	{ 
		if(type == ET_DATA)
		{    
			if(data->len > MAX_EVENT_DATA_CNT)
				return false;
			lister->data.data = (unsigned char *)malloc(MAX_EVENT_DATA_CNT);
			memcpy(lister->data.data, data->data, data->len);
			lister->data.len = data->len;
		}
		else
		{
		    memcpy(&(lister->status), status, sizeof(EventStaus));
		}
		lister->type = type;
		lister->isActive = true;
		list_add(&(lister->node), &queue->listHead); //向 list_head  的队首追加
		return true;
	}

	return false;
}

/* 从链表中出队 每次只能出一个 */
bool getFromEventList(EventListQueue *queue, EventType *type, EventStaus *status, EventData *data)
{
	EventList *lister = NULL;

	list_for_each_entry_reverse(lister, EventList, &queue->listHead, node)
	{
		if(lister->type == ET_DATA)
		{
			data->len = lister->data.len;
			memcpy(data->data, &(lister->data.data), data->len);
			free(lister->data.data);
		}
		else
		{
			memcpy(status, &(lister->status), sizeof(EventStaus));
		}
		*type = lister->type;

		list_del(&lister->node);
		memset(lister, 0, sizeof(EventList));
		lister->isActive = false;
		return true;
	}
	return false;
}

/* 执行一遍链表中的ET_LOOPTASK任务 */
typedef void (*loop_task_fun)(void);

void EventQueue_runTask(EventListQueue *queue)
{
	loop_task_fun fun;
	EventList *current = NULL;
	list_for_each_entry_reverse(current, EventList, &queue->listHead, node)
	{
		if(current->type == ET_LOOPTASK)
		{
			fun = (loop_task_fun)current->status.fun;
			fun();
		}
	}
}

5.示例

5.1 初始化事件管理器

static EventListQueue g_normalEventQueue;   
static EventListQueue g_loopTaskEventQueue;     
static EventListQueue g_dataEventQueue; 

bool init()
{
	/* 申请 N个 单独存放循环任务的事件队列 */
	if (eventListIint(&g_loopTaskEventQueue, N) == false)
		return false;
	/* 申请 N个 一般事件 (一般任务事件 + 定时器事件) */
	if (eventListIint(&g_normalEventQueue, N) == false)
		return false;
	/* 申请 N个 数据事件  */
	if (eventListIint(&g_dataEventQueue, N) == false)
		return false;

    return true;
}

5.2 事件的扫描+事件的出队

EventType syspara_eventProcess(int *msg_1, int *msg_2, unsigned char *msg_data, int *msg_len)
{
    EventType type; 
	EventStaus status;
    EventData data; 
    data.data = &msg_data;
    
    /* 1. 循环任务事件 优先度最高 每次都执行一遍 */
    EventQueue_runTask(&g_loopTaskEventQueue);

    /* 2. 一般事件 定时器消息任务 > 普通任务 > 数据事件*/
	while (getEvent_listCnt(&g_normalEventQueue))
	{
		if (getFromEventList(&g_normalEventQueue, &type, &status, &data))
		{
			if (type == ET_TIMER)
			{
				//定时器消息任务（除循环任务外最高优先度的任务） 一旦发现马上 TODO
				timer_callback fun; 
				fun = (timer_callback)status.fun;
				fun(status.status_1, status.status_2);
			}
			else if (type == ET_TASK)
			{
                /* 发现普通任务直接返回 */
				*msg_1 = status.status_1;
				*msg_2 = status.status_2;
                free(data.data);
				return ET_TASK;
			}
		}
	}
    /* 3. 数据事件 */
	if (getEvent_listCnt(&g_dataEventQueue) >= 1)
	{
        if (getFromEventList(&g_dataEventQueue, &type, &status, &data))
		{
            if (type == ET_DATA)
			{
                *msg_len = data.len;
                return ET_DATA;
            }
		}
	}

	return ET_NONE;
}

int main(void)
{
	...;

	int msg_1; 
	int msg_2; 
	int msg_len; 
	unsigned char *msg_data =  (unsigned char *)malloc(MAX_EVENT_DATA_CNT);
	while (1)
	{
		EventType  ret = syspara_eventProcess(&msg_1, &msg_2, msg_data, &msg_len);
  	    switch (ret)
		{
		case ET_NONE:
		     //todo
			break;
		case ET_TASK: 
		    //todo
			break;
		case ET_DATA:
		    //todo
			break;
		default:
            // 在syspara_eventProcess中已经执行完毕
			break;
		}
		usleep(N);
	}
	return;
}

5.3 添加事件

bool syspara_addLoopTask(void *fun, int status_1, int status_2)
{
	EventStaus status;
	status.fun = fun;
	status.status_1 = status_1;
	status.status_2 = status_2;
    return addToEventList(&g_loopTaskEventQueue, ET_LOOPTASK, &status, NULL);
}

CJourneys

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C程序设计：基于循环双向链表的事件管理器

基于循环双向链表的事件管理系统是一种用于管理事件的数据结构。它可以用于多种场景，包括计划任务、调度、日程安排等。原理如下：事件节点：每个事件都被表示为一个节点，每个节点包含一些必要的属性，比如事件的名称、开始时间、结束时间等。节点之间通过指针连接形成链表。循环链表：链表的最后一个节点的下一个节点指针指向链表的第一个节点，形成一个循环链表。这样可以方便地进行遍历和循环操作。双向链表：除了通常的单向指针外，每个节点还包含一个指向前一个节点的指针。这样可以在链表中高效地进行向前或向后遍历。
复制链接

扫一扫