数据队列的用因及用法

最新推荐文章于 2024-05-21 17:58:04 发布
置顶 最新推荐文章于 2024-05-21 17:58:04 发布
阅读量1.7k 收藏 3
点赞数 4
分类专栏： 数据收发 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37733540/article/details/107584820
版权

环形数据队列

文章目录

在日常收发数据过程中，尤其多线程操作，数据的收发需要用到数据队列去处理，那么为什么要使用数据队列？什么是数据队列呢？

常规存储机制弊端

在接收或者发送数据的时候，你的数据的存储机制是什么样的呢 ？

  • 是否是采用下述方式？
#define MAX_BUF_SIZE    2048

unsigned short  recv_len;
unsigned char   recv_buf[MAX_BUF_SIZE];

int main()
{
    ......
    while(1)
    {
        recv_len = receive(recv_buf);
        ......
    }
}
  • 此种方法如果在单线程中问题不大，但是不适合多线程，多线程中，通常接收和发送函数是和主线程分离开来的，例如：

#define MAX_BUF_SIZE    2048

unsigned short  recv_len;
unsigned char   recv_buf[MAX_BUF_SIZE];

void *recv_thread(void *arg)
{   
    int ret;

    while(1)
    {   
        ret = receive(recv_buf); /* 如果接收到数据，则返回值为接收字节数 */
        if(ret > 0)
        {
            recv_len = ret;
        }
    }
}

int main()
{   
    pthread_t thread_other;
    ......
    
    /* 创建接收线程，主要作用是负责接收数据 */
    pthread_create (&thread_other, NULL, recv_thread, NULL);

    while(1)
    {
        if(recv_len > 0)
        {
            /* 处理接收 buf */
            ......
        }
    }
    return 0;
}

代码弊端：上述代码模仿单线程的接收处理，但是显然问题很大，因为处理和接收在不同线程，处理线程正在处理数据过程中，有可能接收线程又接收到新数据，导致处理线程处理的数据被覆盖掉，会导致意想不到的后果。

解决方法：多线程操作中，我们希望：如果前一次接收到的数据还没有处理结束，此时又有新数据到来，我们希望新数据不会将未处理的数据覆盖掉，而是存储到未处理数据后面，等上一次数据处理结束后再处理新数据，这就是数据队列的存储机制。

数据队列的实现

数据队列的核心就是数据的入栈和出栈。下述代码中，Data_Queue 就是数据队列，PutData 和 DropData 分别是数据的入栈和出栈：


#define MAX_DATA_SIZE   2048

typedef struct  
{
    unsigned short start;               //目前处理到的数据索引
    unsigned short next;                //最新入栈的数据索引
    unsigned short count;               //待处理数据数量
    unsigned short size;                //缓冲区大小
    unsigned char  buf[MAX_DATA_SIZE];  //数据缓冲区
}Data_Queue;

/*******************************************************************
* funcname:	QueueInit(Data_Queue *data_queue)
* para:	    data_queue-数据队列
* function:	数据队列初始化
* return:	
********************************************************************/
void QueueInit(Data_Queue *data_queue)
{
    (*data_queue).next = 0;
    (*data_queue).start = 0;
    (*data_queue).count = 0;
    (*data_queue).size = MAX_DATA_SIZE;
}

/*******************************************************************
* funcname:	PutData
* para:	    data_queue-数据队列，data-入栈数据
* function:	数据入栈
* return:	
********************************************************************/
void PutData(Data_Queue *data_queue, unsigned char data)
{
    (*data_queue).buf[(*data_queue).next++] = data;         //数据入栈

    if((*data_queue).next >= (*data_queue).size)            //入栈数据索引超过到缓冲区最大索引后，归零
    {
        (*data_queue).next = 0;
    }

    (*data_queue).count++;
    if((*data_queue).count >= (*data_queue).size)           //未处理的数据超多缓冲区容量后，舍弃旧数据，保留新数据
    {
        (*data_queue).count = (*data_queue).size;
        (*data_queue).start++;
        if((*data_queue).start >= (*data_queue).size)       //已处理数据索引超过到缓冲区最大索引后，归零
        {
            (*data_queue).start = 0;
        }
    }
}

/*******************************************************************
* funcname:	DropData
* para:	    data_queue-数据队列
* function:	数据出栈
* return:	
********************************************************************/
void DropData(Data_Queue *data_queue)
{
    if(((*data_queue).next == (*data_queue).start) && 
        ((*data_queue).count != (*data_queue).size))       //数据处理完毕直接返回
    {
        (*data_queue).count = 0;
        return;
    }

    (*data_queue).start++;                              //已处理数据索引 + 1
    if((*data_queue).start >= (*data_queue).size)
    {
        (*data_queue).start = 0;
    }

    if((*data_queue).count > 0)                         //未处理数据 -1
    {
        (*data_queue).count--;
    }
    
    return;
    

}

数据队列实战

1.数据队存储机制

此示例可以解决常规存储机制的弊端：


#define MAX_BUF_SIZE    2048

typedef struct  
{
    unsigned short start;               //目前处理到的数据索引
    unsigned short next;                //最新入栈的数据索引
    unsigned short count;               //待处理数据数量
    unsigned short size;                //缓冲区大小
    unsigned char  buf[MAX_BUF_SIZE];   //数据缓冲区
}Data_Queue;

Data_Queue data_queue;

void *recv_thread(void *arg)
{   
    int ret,i;
    unsigned short  recv_len;
    unsigned char   recv_buf[MAX_BUF_SIZE];

    while(1)
    {   
        recv_len = receive(recv_buf); /* 如果接收到数据，则返回值为接收字节数 */
        if(recv_len > 0)
        {
            for(i=0;i<recv_len;i++)
            {
                PutData(&data_queue,recv_buf[i]);
            }
        }
    }
}

int read(unsigned char *read_buf)
{   
    int i = 0;
    while(data_queue.count)
    {
        read_buf[i++] = data_queue.buf[start];
        DropData(&data_queue);
    }

    return i;
}

int main()
{   
    unsigned char read_buf[MAX_BUF_SIZE];
    pthread_t thread_other;

    /* 初始化数据队列 */
    QueueInit(&data_queue);
    ......
    
    /* 创建接收线程，主要作用是负责接收数据 */
    pthread_create (&thread_other, NULL, recv_thread, NULL);

    while(1)
    {
        if(read(read_buf) > 0)
        {
            /* 处理接收 buf */
            ......
        }
    }
    return 0;
}

2.利用数据队列处理接收到的特定字段

我们期望的是接收到的每个消息帧都是我们所需要的完整报文，但是现实往往不会和我们期望的一样。即：一帧消息里面往往包含多组我们需要的报文，我们需要将多组报文都处理；或者说多帧消息才能组成一组我们需要的报文段，我们需要将多个消息帧组成完整的报文段后再处理。这两个难题我们依然可以使用数据队列来解决。

例如：我们需要的消息帧以 0x68 开头，0x16 结尾，帧头后两个字节表示帧长度，此长度不包括帧头帧尾，我们把这个消息帧称为 698 报文。

  1. 举例1 ：一帧消息帧中包含多个 698 报文，依次处理
    示例报文1：68 30 00 01 05 01 00 00 00 00 00 00 52 D9 81 00 00 07 E4 03 0F 00 09 01 23 00 00 07 E4 08 03 01 0D 28 34 CC 01 07 E4 08 03 01 0D 28 34 CC 01 50 80 16
    示例报文2:68 1E 00 81 05 01 00 00 00 00 00 00 D2 B6 01 00 00 00 3C 07 E4 03 0F 00 09 01 23 00 00 3F ED 16
    接收到的消息帧中包含这两组示例报文，即：示例报文1+示例报文2：
    68 30 00 01 05 01 00 00 00 00 00 00 52 D9 81 00 00 07 E4 03 0F 00 09 01 23 00 00 07 E4 08 03 01 0D 28 34 CC 01 07 E4 08 03 01 0D 28 34 CC 01 50 80 16 68 1E 00 81 05 01 00 00 00 00 00 00 D2 B6 01 00 00 00 3C 07 E4 03 0F 00 09 01 23 00 00 3F ED 16
    但是这包含两个 698 报文 的消息帧中，两组报文我们需要按照先后关系做对应处理。

  2. 举例2：多个消息帧，组成一个 698报文。
    示例报文：68 30 00 01 05 01 00 00 00 00 00 00 52 D9 81 00 00 07 E4 03 0F 00 09 01 23 00 00 07 E4 08 03 01 0D 28 34 CC 01 07 E4 08 03 01 0D 28 34 CC 01 50 80 16，这是完整的一组 698 报文。
    接收到3段消息，组合而成才是完整的 698 报文：
    示例消息1：68 30 00 01 05 01 00 00 00 00 00 00 52 D9 81 00 00 07 E4 03 0F 00 09 01
    示例消息2：23 00 00 07 E4 08 03 01 0D 28 34 CC 01 07 E4 08 03 01 0D 28 34 CC
    示例消息3：01 50 80 16
    我们需要将 3 个消息帧组合成我们需要的 698 报文然后处理：

#define MAX_BUF_SIZE    2048

typedef struct  
{
    unsigned short start;               //目前处理到的数据索引
    unsigned short next;                //最新入栈的数据索引
    unsigned short count;               //待处理数据数量
    unsigned short size;                //缓冲区大小
    unsigned char  buf[MAX_BUF_SIZE];   //数据缓冲区
}Data_Queue;

Data_Queue data_queue;

void *recv_thread(void *arg)
{   
    int ret,i;
    unsigned short  recv_len;
    unsigned char   recv_buf[MAX_BUF_SIZE];

    while(1)
    {   
        recv_len = receive(recv_buf); /* 如果接收到数据，则返回值为接收字节数 */
        if(recv_len > 0)
        {
            for(i=0;i<recv_len;i++)
            {
                PutData(&data_queue,recv_buf[i]);
            }
        }
    }
}

/* 此函数可以解决 2 个例子中的问题
*  1. 一帧消息帧中包含多个 698 报文，依次处理
*  2. 多个消息帧，组成一个 698报文，然后再行处理
*  例如我们需要的消息帧以0x68开头，0x16结尾，帧头后两个字节表示帧长度，此长度不包括帧头帧尾 
*/
void read_buf(unsigned char *read_buf)
{
	int ret;
	int	datalen;
	
	if(data_queue.count > 0)
	{
		for(int i=0;i<data_queue.count;i++)
		{
			if(data_queue.buf[mod(data_queue.start+i,data_queue.size)] == 0x68)
			{
				datalen = data_queue.buf[mod(data_queue.start+i+1,data_queue.size)];
				datalen += data_queue.buf[mod(data_queue.start+i+2,data_queue.size)]*256;
				if(data_queue.buf[mod(data_queue.start+i+1+datalen,data_queue.size)]==0x16)
				{	
					while(i--)
						dropdata(&data_queue);
					printf("rec xxxframe,byte = %d\r\n ",datalen+2);
					for(int j=0;j<datalen+2;j++)
					{
						read_buf[j] = data_queue.buf[mod(data_queue.start,data_queue.size)];
						dropdata(data_queue);
						printf("%02X ",read_buf[j]);
					}
					printf("\r\n");
					retrun j;
				}
			}
		}
	}
	return 0;
}

int main()
{   
    unsigned char read_buf[MAX_BUF_SIZE];
    pthread_t thread_other;

    /* 初始化数据队列 */
    QueueInit(&data_queue);
    ......
    
    /* 创建接收线程，主要作用是负责接收数据 */
    pthread_create (&thread_other, NULL, recv_thread, NULL);

    while(1)
    {	
        if(read_buf(read_buf) > 0)
        {
            /* 处理接收 当前buf中的消息 */
            ......
        }
    }
    return 0;
}

总结

上述主要以接收为例，说明了使用数据队列的原因以及用法，发送数据其实也一样，只需要在发送前 PutData，然后在发送结束后，DropData 即可。

汤梦飞123
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
QT实时绘制串口数据
07-20
采用多线程方法，主线程解析数据和绘图，子线程接收数据，QWT绘图，有历史回顾功能
【QT学习】多线程开发中线程间的数据传输问题
qq_64373004的博客
04-20 241
今天在对软件进行测试开发时，为了解决软件在运行视频显示和串口接发过程中的卡顿问题，创建了两个子线程来运行两个功能。在使用moveToThread()函数将串口功能添加进新线程并编译运行时，出现了如下图所示的问题：这个问题的意思是在connect时无法对“QTextCursor”类型的参数进行排队，除此之外并没有其他的错误提示信息，也没有打印具体的错误位置。
数据结构：队列的详解
最新发布
qq_58356691的博客
05-21 298
队列详解
queue的长度_python线程之七：线程间通信queue，最全、最明白阐述
weixin_39855944的博客
11-23 574
queue模块：消息安全地在多线程间交换，实现了多生产者、多消费者队列看源码 queue 模块包含四个实用的类：一、三种队列：1、Queue()、SimpleQueue()：先进先出队列2、LifoQueue()：先进后出队列3、PriorityQueue()：优先级队列，优先级编号，按ascii码表的顺序从小到大输出数据格式：(优先级编号，数据)二、四个类的实例化方法：Queue()：默认0，小...
typedef 妙用
newish21的专栏
02-28 613
typedef void (*Action)(); void State0(); void State1(); void State2(); void State3(); void State4(); Action StateTransition[StateNum]={State0,State1,State2,State3,State4}; int state=0; StateTransition
Hadoop之DataNode
每天进步一点点
05-06 2738
目录 1.DataNode是什么？ 2.DataNode做什么？ 3.DataNode怎么做？ 1.DataNode是什么？ Datanode是HDFS文件系统的工作节点，它们根据客户端或者是namenode的调度进行存储和检索数据，并且定期向namenode发送它们所存储的块(block)的列表。 2.DataNode做什么？ Datanode以存储数据块(Block)的形式保存H...
RT-Thread 隐藏的宝藏之 data_queue
whj123999的博客
02-27 1955
1. data_queue 是什么 data_queue 直接翻译过来是 数据队列。这个名字和 消息队列 很像。那么他们有什么区别呢？ 消息队列：消息队列能够接收来自线程或中断服务例程中不固定长度的消息，并把消息缓存在自己的内存空间中。其他线程也能够从消息队列中读取相应的消息，而当消息队列是空的时候，可以挂起读取线程。当有新的消息到达时，挂起的线程将被唤醒以接收并处理消息。消息队列是一种异步的通信方式。(摘自 RT-Thread文档中心). 数据队列：没有找到官方详细的说明，只是在 RT-Thread AP
《面向对象的用电信息数据交换协议》-698协议的理解
weixin_42204499的博客
08-24 2万+
《面向对象的用电信息数据交换协议》-698协议的理解 写在前面 DL/T 698.45是面对对象的通信协议，适用于主站和采集终端、采集终端和电能表、主站和电能表之间。DL/T 645是面向过程的通信协议适用于采集终端和电能表之间。698是最新的协议，645是旧协议。 面向过程：数据和方法是分离的，同类的数据散装在一起,封装性差。 面向对象：把相关的数据和方法组合为一个整体来看待。 面向对象必然有类和对象： 类描述了一组有相同特性(属性)和相同行为(方法)的对象。在DL/T 698协议中具有共享公共特征的对象
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
队列 数据类型及Python实现
12-21
`dequeue`方法使用了`pop()`，这会删除并返回列表的最后一个元素，即队列的头部元素，时间复杂度为O(1)。如果为了优化`enqueue`操作，可以考虑使用`append(item)`，其时间复杂度为O(1)，但这样会使`dequeue`操作变得...
C#多线程处理多个队列数据的方法
09-03
本示例介绍了一种利用ThreadPool类和委托来实现多线程处理多个队列数据的方法。以下是详细的知识点解析： 1. **线程池(ThreadPool)**: ThreadPool是一个系统级线程池，它负责管理和调度线程。通过ThreadPool，...
c# 线程安全队列的用法原理及使用示例
01-21
什么是线程安全？ 答：线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程...先看下线程安全队列的用法： ConcurrentQueue<int> ts = new System.Collections.Concurrent.ConcurrentQueue
数据结构-使用javascript讲解数据结构之队列.zip
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
698通信协议总结
热门推荐
gxm91716的博客
12-19 4万+
698通信协议培训阶段性总结 为了适应国家电网改革发展的需要，为了使我们形成一个对698协议专业的认知，以及培养我们基本的开展项目技能，特此，结合自己以前对698协议的理解以及培训后的心得体会，写一些阶段性的总结。   我对698协议的学习感受是难懂，大体看了几遍还是不太清楚是怎么运用的，模糊的理解了采用面向对象的思想对接口类的方法以及基本的通信架构，但对详细的还是没有看懂，经过一天的
数据结构之队列
猎户星座
02-24 692
1、队列的基本概念 队列（queue）是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 　　队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—firs
【数据结构】队列详解
wangduduniubi的博客
05-19 3241
队列的结构和栈完全相反，栈只能再栈顶进再从栈顶出，遵从后进先出（LIFO）；而队列 本篇要分享的内容是队列的解析和增删查改的使用。队列的结构和栈完全相反，栈只能再栈顶进再从栈顶出，遵从后进先出（LIFO）；而队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，遵循的是先进先出，后进后出。入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头
数据结构——队列
weixin_53230235的博客
04-06 803
数据结构——队列——循环队列
qt串口发送16进制数据
05-21
在 Qt 中，可以使用 `QSerialPort` 类来实现串口通信，并通过 `write()` 方法向串口发送数据。如果要发送 16 进制数据，可以将其转换为字节数组后发送。 以下是一个示例代码，其中 `data` 是要发送的 16 进制数据，`size` 是数据长度： ```cpp QByteArray hexData = QByteArray::fromHex(data, size); // 将 16 进制数据转换为字节数组 QSerialPort serialPort; serialPort.setPortName("COM1"); // 设置串口名 serialPort.setBaudRate(QSerialPort::Baud9600); // 设置波特率 serialPort.setDataBits(QSerialPort::Data8); // 设置数据位 serialPort.setParity(QSerialPort::NoParity); // 设置校验位 serialPort.setStopBits(QSerialPort::OneStop); // 设置停止位 if (serialPort.open(QIODevice::WriteOnly)) { // 打开串口 serialPort.write(hexData); // 发送数据 serialPort.close(); // 关闭串口 } ``` 在上述代码中，首先将 16 进制数据转换为字节数组，然后设置串口参数并打开串口，最后通过 `write()` 方法向串口发送数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

汤梦飞123

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值