上位机开发笔记：环形缓冲区

最新推荐文章于 2024-04-11 16:07:18 发布
最新推荐文章于 2024-04-11 16:07:18 发布
阅读量1.8k 收藏 30
点赞数 7
分类专栏： 上位机开发笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingxiaoxv/article/details/128182717
版权

文章目录

前言

环形缓冲区(Ring buffer/Circular buffer)或称环形队列，是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。比如对通信中接收到的数据进行处理，当数据量太大或者处理速度跟不上接收速度时，就会将之前还未处理的数据覆盖掉，即出现丢包的现象。此时，使用环形缓冲区就可以有效解决这一问题。

1. 环形缓冲区工作机制

环形缓冲区是一种先进先出(FIFO)的数据结构，本质上就是将一个顺序存储结构的访问逻辑由线性处理为环形，通常由一个固定大小的顺序容器实现，通过一定的方法对数据的读写范围进行控制。

1.1 实现原理

一般地，环形缓冲区通过读写指针控制读写范围：

  • 读指针：指向缓冲区内下一个可读数据的位置。
  • 写指针：指向缓冲区内下一个可写数据的位置。

初始化时，读指针和写指针都指向缓冲区的0号元素，通过移动这两个指针即可对缓冲区的数据进行读写操作。当指针移动到容器末尾时，立即返回容器头以实现首尾相连的环形结构。

在这里插入图片描述

1.2 区分缓冲区满或者空

缓冲区是满或是空，都有可能出现读指针与写指针指向同一位置，有多种策略用于检测缓冲区是满或是空：

在这里插入图片描述

1) 总是保持一个存储单元为空

缓冲区中总是有一个存储单元保持未使用状态，此时缓冲区最多存入size - 1个数据。如果读写指针指向同一位置，则缓冲区为空；如果读指针位于写指针的相邻后一个位置，则缓冲区为满。

数据结构：

typedef struct
{
    unsigned int size;
    unsigned int writeIndex;
    unsigned int readIndex;
    unsigned char *buff = nullptr;
} RING_BUFFER;

缓冲区满空判断：

bool ringBufferIsEmpty(const RING_BUFFER &rb)
{
    return rb.writeIndex == rb.readIndex; //如果读写指针指向同一位置，则缓冲区为空。
}

bool ringBufferIsFull(const RING_BUFFER &rb)
{
    //通过除余缓冲区大小实现环形索引
    return ((rb.writeIndex + 1) % rb.size) == (rb.readIndex % rb.size); //如果读指针位于写指针的相邻后一个位置，则缓冲区为满。
}

缓冲区写入数据：

一般来说，写操作禁止覆盖缓冲区的数据，采取返回一个错误码或者抛出异常的策略。但在某些情况下覆盖环形缓冲区中未被处理的数据是允许的，特别是在多媒体处理时。例如，音频的生产者可以覆盖掉声卡尚未来得及处理的音频数据。

int writeToRingBuffer(RING_BUFFER &rb, unsigned char *szData, int iLen)
{
    if (ringBufferIsFull(rb))
    {
        return -1;
    }

    //先判断可写数据数量
    int available = 0;
    if (rb.writeIndex >= rb.readIndex)
    {
        available = rb.size - (rb.writeIndex - rb.readIndex) - 1; //写指针不能写到读指针所在位置，要保持一个存储单元
    }
    else
    {
        available = rb.readIndex - rb.writeIndex - 1;
    }
    if (iLen > available)
    {
        // return -2; //抛出异常并退出
        iLen = available; //修改写入数据数量
    }

    //跨越边界要进行分段拷贝
    if ((rb.writeIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - rb.writeIndex;
        unsigned int len2 = iLen - len1;
        memcpy(rb.buff + rb.writeIndex, szData, len1);
        memcpy(rb.buff, szData + len1, len2);
        rb.writeIndex = len2;
    }
    else
    {
        memcpy(rb.buff + rb.writeIndex, szData, iLen);
        rb.writeIndex += iLen;
    }
    return 0;
}

缓冲区读取数据：

int readFromRingBuffer(RING_BUFFER &rb, unsigned char *szData, int &iLen)
{
    if (ringBufferIsEmpty(rb))
    {
        return -1;
    }

    //先判断可读数据数量
    int available = 0;
    if (rb.writeIndex >= rb.readIndex)
    {
        available = rb.writeIndex - rb.readIndex; //读指针可以读到写指针的位置，此时缓冲区为空
    }
    else
    {
        available = rb.size - (rb.readIndex - rb.writeIndex);
    }
    if (iLen > available)
    {
        iLen = available;
    }

    //跨越边界要进行分段拷贝
    if ((rb.readIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - rb.readIndex;
        unsigned int len2 = iLen - len1;
        memcpy(szData, rb.buff + rb.readIndex, len1);
        memcpy(szData + len1, rb.buff, len2);
        rb.readIndex = len2;
    }
    else
    {
        memcpy(szData, rb.buff + rb.readIndex, iLen);
        rb.readIndex += iLen;
    }
    return 0;
}

这种策略的优点是简单、粗暴，缺点是语义上实际可存数据量与缓冲区容量不一致，且多线程时需要并发控制。

2) 使用计数数据

这种策略需要在数据结构内添加一个变量保存缓冲区内存储数据的计数，写操作增加计数、读操作减少计数。如果存储数据数量为0，则缓冲区为空；如果存储数据数量等于缓冲区容量，则缓冲区为满。

数据结构：

typedef struct
{
    unsigned int size;
    unsigned int writeIndex;
    unsigned int readIndex;
    unsigned int buffCount; //存储数据计数
    unsigned char *buff = nullptr;
} RING_BUFFER;

缓冲区满空判断：

bool ringBufferIsEmpty(const RING_BUFFER &rb)
{
    return 0 == rb.buffCount;
}

bool ringBufferIsFull(const RING_BUFFER &rb)
{
    return rb.buffCount == rb.size;
}

缓冲区写入数据：

int writeToRingBuffer(RING_BUFFER &rb, unsigned char *szData, int iLen)
{
    if (ringBufferIsFull(rb))
    {
        return -1;
    }

    int available = rb.size - rb.buffCount;
    if (iLen > available)
    {
        // return -2;
        iLen = available;
    }

    if ((rb.writeIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - rb.writeIndex;
        unsigned int len2 = iLen - len1;
        memcpy(rb.buff + rb.writeIndex, szData, len1);
        memcpy(rb.buff, szData + len1, len2);
        rb.writeIndex = len2;
    }
    else
    {
        memcpy(rb.buff + rb.writeIndex, szData, iLen);
        rb.writeIndex += iLen;
    }
    rb.buffCount += iLen;
    return 0;
}

缓冲区读取数据：

int readFromRingBuffer(RING_BUFFER &rb, unsigned char *szData, int &iLen)
{
    if (ringBufferIsEmpty(rb))
    {
        return -1;
    }

    int available = rb.buffCount;
    if (iLen > available)
    {
        iLen = available;
    }

    if ((rb.readIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - rb.readIndex;
        unsigned int len2 = iLen - len1;
        memcpy(szData, rb.buff + rb.readIndex, len1);
        memcpy(szData + len1, rb.buff, len2);
        rb.readIndex = len2;
    }
    else
    {
        memcpy(szData, rb.buff + rb.readIndex, iLen);
        rb.readIndex += iLen;
    }
    rb.buffCount -= iLen;
    return 0;
}

该策略的优点是运算速度快、使用简单。缺点是读写操作都需要修改这个存储数据计数，对于多线程访问缓冲区需要并发控制。

还有一种实现方法是用2个变量分别保存写入、读出缓冲区的数据数量，其差值就是缓冲区中尚未被处理的有效数据的数量。如果写入数据数量与读出数据数量相等，则缓冲区为空；如果写入数据数量与读出数据数量的差值等于缓冲区容量，则缓冲区为满。

数据结构：

这种策略甚至可以省略读写指针，通过读写数据数量%缓冲区容量就可以实现索引访问。

typedef struct
{
    unsigned int size;
    unsigned long writeNum;
    unsigned long readNum;
    unsigned char *buff = nullptr;
} RING_BUFFER;

缓冲区满空判断：

bool ringBufferIsEmpty(const RING_BUFFER &rb)
{
    return rb.writeNum == rb.readNum;
}

bool ringBufferIsFull(const RING_BUFFER &rb)
{
    return rb.writeNum == (rb.readNum + rb.size);
}

缓冲区写入数据：

int writeToRingBuffer(RING_BUFFER &rb, unsigned char *szData, int iLen)
{
    if (ringBufferIsFull(rb))
    {
        return -1;
    }

    int available = rb.size - (rb.writeNum - rb.readNum);
    if (iLen > available)
    {
        //return -2;
        iLen = available;
    }

    unsigned int writeIndex = rb.writeNum % rb.size;
    if ((writeIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - writeIndex;
        unsigned int len2 = iLen - len1;
        memcpy(rb.buff + writeIndex, szData, len1);
        memcpy(rb.buff, szData + len1, len2);
    }
    else
    {
        memcpy(rb.buff + writeIndex, szData, iLen);
    }
    rb.writeNum += iLen;
    return 0;
}

缓冲区读取数据：

int readFromRingBuffer(RING_BUFFER &rb, unsigned char *szData, int &iLen)
{
    if (ringBufferIsEmpty(rb))
    {
        return -1;
    }

    int available = rb.writeNum - rb.readNum;
    if (iLen > available)
    {
        iLen = available;
    }

    unsigned int readIndex = rb.readNum % rb.size;
    if ((readIndex + iLen) >= rb.size)
    {
        unsigned int len1 = rb.size - readIndex;
        unsigned int len2 = iLen - len1;
        memcpy(szData, rb.buff + readIndex, len1);
        memcpy(szData + len1, rb.buff, len2);
    }
    else
    {
        memcpy(szData, rb.buff + readIndex, iLen);
    }
    rb.readNum += iLen;   
    return 0;
}

3) 镜像指示位

一般情况下，环形缓冲区的长度如果是n，则读写指针可访问的范围为0～n-1。该策略规定读写指针的可访问范围为0～2n-1，其中0～n-1对应于常规的逻辑地址空间，n至2n-1为镜像逻辑地址空间。

在这里插入图片描述

使用一位表示写指针或读指针是否进入了虚拟的镜像存储区：置位表示进入，不置位表示没进入。在读写指针的值相同情况下，如果二者的指示位相同，说明缓冲区为空；如果二者的指示位不同，说明缓冲区为满。

相关代码可查看：维基百科-环形缓冲区

这种方法优点是判断缓冲区满/空很简单、不需要做取余数操作，读写线程可以分别设计专用算法策略，能实现精致的并发控制。 缺点是读写指针各需要额外的一位作为指示位。

2. Qt实现环形缓冲区

2.1 QByteArray环形缓冲区

Qt中专门封装了字节数组QByteArray类，使得我们可以灵活地分配字节数组的内存，不用每次都在堆内存上创建，杜绝了内存泄漏的风险。此外，QByteArray几乎可以说是为通信编程量身定制，不同于QString里面存的是Unicode编码的字符串，QByteArray内存储的是没有经过编码的原始数据。对于上述的环形缓冲区就可以用QByteArray进行改写，这里采用读/写计数的方式：

数据结构：

typedef struct
{
    unsigned int size;
    unsigned int writeNum;
    unsigned int readNum;
    QByteArray buff;
} RING_BUFFER;

初始化：

void initRingBuffer(RING_BUFFER &rb, unsigned int sz)
{
    rb.size = sz;
    rb.readNum = 0;
    rb.writeNum = 0;
    rb.buff.resize(sz); //使用resize()设置数组的大小，每个元素初始化为0
}

缓冲区满空判断与上文相同。

缓冲区写入数据：Qt中绝大部分的通信API都是以char*为基本数据格式的，可以直接将char*作为参数写入缓冲区。

int writeToRingBuffer(RING_BUFFER &rb, char *szData, int iLen)
{
    if (ringBufferIsFull(rb))
    {
        return -1;
    }

    mutex.lock();
    int available = rb.size - (rb.writeNum - rb.readNum);
    mutex.unlock();
    if (iLen > available)
    {
        //return -2;
        iLen = available;
    }

    QByteArray arr(szData, iLen); //通过QByteArray的构造函数将char*转为QByteArray
    for(auto it = arr.cbegin(); it != arr.cend(); ++it)
    {
        rb.buff[rb.writeNum % rb.size] = *it;
        ++rb.writeNum;
    }

    return 0;
}

缓冲区读取数据：

int readFromRingBuffer(RING_BUFFER &rb, QByteArray &arr, int &iLen)
{
    if (ringBufferIsEmpty(rb))
    {
        return -1;
    }

    mutex.lock();
    int available = rb.writeNum - rb.readNum;
    mutex.unlock();
    if (iLen > available)
    {
        iLen = available;
    }

    for (int i = 0; i < iLen; ++i)
    {
        arr.push_back(rb.buff.at(rb.readNum % rb.size));
        ++rb.readNum;
    }
    return 0;
}

2.2 QSemaphore实现环形缓冲区

在实际使用中，对环形缓冲区的读/写操作通常都是由不同线程进行的，不同线程对同一资源进行操作，使用信号量处理更加合适。Qt中使用QSemaphore类实现信号量，用2个信号量分别表示可读/可写资源数量，通过读写计数实现索引。

数据结构：

/*---------------------------global.h----------------------------*/
extern const quint32 BUFFERSIZE;
extern QByteArray g_szBuffer;
extern QSemaphore freeBytes;
extern QSemaphore usedBytes;
extern quint32 writeNum;
extern quint32 readNum;
extern QMutex g_mutex;

/*---------------------------global.cpp----------------------------*/
#include "global.h"

const quint32 BUFFERSIZE = 10;
QByteArray g_szBuffer(BUFFERSIZE, '\0');
QSemaphore freeBytes(BUFFERSIZE);
QSemaphore usedBytes;
quint32 writeNum = 0;
quint32 readNum = 0;
QMutex g_mutex;

缓冲区写入数据：

void writeToRingBuffer(char *szData, int iLen)
{
    if(szData == nullptr || iLen == 0)
    {
        return;
    }
    
	if(freeBytes.available() - iLen < 0)
    {
    	iLen = freeBytes.available();
    }
    freeBytes.acquire(iLen);

    g_mutex.lock();
    QByteArray arr(szData, iLen);
    for(auto it = arr.cbegin(); it != arr.cend(); ++it)
    {
        g_szBuffer[writeNum % BUFFERSIZE] = *it;
        ++writeNum;
    }
	usedBytes.release(iLen);
	g_mutex.unlock();
}

缓冲区读取数据：

void readFromRingBuffer(QByteArray &arr, int &iLen)
{
    if(usedBytes.available() - iLen < 0)
    {
    	iLen = (usedBytes.available() == 0)? 1 : usedBytes.available(); //保证acquire的个数不为0
    }
    usedBytes.acquire(iLen);
    
    mutex.lock();
    for (int i = 0; i < iLen; ++i)
    {
        arr.push_back(g_szBuffer.at(readNum % BUFFERSIZE));
        ++readNum;
    }
    freeBytes.release(iLen);
    mutex.unlock();
}

调用信号量void QSemaphore::acquire(int n = 1)函数，如果n > available()，则线程将一直阻塞直到该信号量获得足够资源。

Qt的信号量使用详见我的这篇博客：Qt学习笔记：多线程的使用

参考资料

Wiki - Circular buffer

环形缓冲区C语言实现

STM32进阶之串口环形缓冲区实现

dingxiaoxv
关注
  • 7
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程 环形缓冲区_使用环形缓冲区有效登录多线程应用程序
cusi77914的博客
06-21 1017
“有两种编写无错误程序的方法；只有第三种有效。” -艾伦·J·佩利斯 在关键计算机应用程序的生命周期中，日志记录是非常重要的活动，尤其是在故障症状不明显时。 日志记录提供了故障之前应用程序状态的最大详细信息，例如变量的值，函数的返回值等。 在一段时间内会生成单调增加的跟踪数据，并将其连续写入磁盘上的文本文件中。 有效的日志记录需要大量磁盘空间，并且在多线程环境中（其中有多个线程写入其跟踪信...
环形缓冲区
蜜汁程序员的博客
10-20 2万+
https://blog.csdn.net/p23onzq/article/details/80750745 .https://blog.csdn.net/blade2001/article/details/7094232/ 正在造轮子，同时不停地在找哪里有这个轮子 原因： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释...
一种基于镜像指示位办法的RingBuffer实现，解决Mirror和2的幂个数限制
最新发布
wenbo13579的专栏
04-11 785
一种基于镜像指示位办法的RingBuffer实现，解决Mirror和2的幂个数限制
freeRtos队列的使用
lovesjj_1011的博客
12-07 454
队列是一个环形缓冲区很多生产者生产很多数据，很多消费者读数据，唤醒之后首先是执行高优先级的，同等优先级先执行等待时间长的。无论是写数据还是读数据都会有一个超时时间，写数据当队列已经满了就等待一会，当读数据队列已经空了可以等待一会。
深入理解MapReduce中环形缓冲区的概念
FullStackDeveloper0的博客
10-17 6980
MapReduce过程图解： 标题 环形缓冲区图示： 环形缓冲区                      Map的输出结果是由collector处理的，每个Map任务不断地将键值对输出到在内存中构造的一个环形数据结构中。使用环形数据结构是为了更有效地使用内存空间，在内存中放置尽可能多的数据。                          这个数据结构其实就是个字节数组byte[]...
arrayBuffer(环形缓冲区)
04-19
设计了一个环形字节缓冲区类，可用于通信数据收发的缓冲处理。类的读写及查看接口已经加上了多线程同步访问锁
环形缓冲区(ring buffer)，环形队列(ring queue) 原理
code09的专栏
02-28 2万+
1. 序言 环形缓冲区(ring buffer)，环形队列(ring queue) 多用于2个线程之间传递数据，是标准的先入先出(FIFO)模型。 一般来说，对于多线程共享数据，需要使用mutex来同步，这样共享数据才不至于发生不可预测的修改/读取，然而， mutex的使用也带来了额外的系统开销，ring buffer/queue 的引入，就是为了有效地解决这个问题，因其特殊的结构 及算法
C# .NET工控上位机开发
06-04
本文将详细探讨C# .NET在工控上位机开发中的应用，以及相关的核心知识点。 一、C#语言基础 C#是一种面向对象的编程语言，由微软公司开发，主要用于.NET Framework平台。它的语法简洁明了，支持类型安全和垃圾回收，...
ahe.rar_can上位机_http://www.ahedu._对话框与窗口
09-24
总结起来，这个项目是使用Visual Basic 6开发的一个CAN总线上位机应用程序，实现了与下位机之间的数据传输。用户界面由多个窗体组成，可能包括对话框和窗口，用于数据的显示和交互。通过引入外部DLL库（如...
Modbus上位机软件：MThings V0.2.2
07-18
Modbus上位机软件，包含模拟主机、模拟从机功能，中文，免费
环形队列实现源码(c++)+通信开发必用
07-11
环形队列实现源码(c++)实现代码，做单片机或PC上位机通信程序开发经常用的数据结构，非常有用，本人已经用在多个项目中。
Qt程序_Qt上位机开发_
10-01
本项目聚焦于使用Qt进行上位机开发，旨在实现与下位机的数据交互。 **Qt库的介绍** Qt库由Qt公司（原名 Trolltech）开发，它提供了丰富的API，支持窗口系统、网络编程、数据库连接、多线程、XML处理等功能。Qt使用...
环形缓冲器（ring buffer，圆形队列）总结-java版
许诗宇的博客
05-15 6557
目录 为什么要有环形缓冲器 简介 区分缓冲区是否为满的策略 总是保持一个存储单元为空 使用数据计数 镜像指示位 java实现 为什么要有环形缓冲器 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释放掉，再处理下一个。那么，已经处理的数据的内存就会被浪费掉。因为后来的数据只能往后排队，如果要将剩余的数据都往前移动一...
STM32进阶之串口环形缓冲区实现
热门推荐
杰杰的博客
06-04 3万+
如需转载请说明出处：STM32进阶之串口环形缓冲区实现 队列的概念 在此之前，我们来回顾一下队列的基本概念： 队列 (Queue)：是一种先进先出(First In First Out ,简称 FIFO)的线性表，只允许在一端插入（入队），在另一端进行删除（出队）。 队列的特点 类似售票排队窗口，先到的人看到能先买到票，然后先走，后来的人只能后买到票 队列的常见两种形式 ...
C语言 环形缓冲区
huizwang的专栏
11-20 2914
/********************************************************************** * Copyright (c), 2012~2016 XiShanTec All Rights Reserved * @file * @brief * @author * @date 2016/05/23 * @version 1.0.0 * @par Revision History: * Da
环形缓冲区实现总结
EDman_linux的专栏
01-04 1513
环形缓冲区的数据结构 1.typedef struct {     char buf[DATA_LENGTH];     char head;     char tail;     char length; } ring_buf 或者 2.typedef struct {     char buf[DATA_LENGTH];     char head;   
初级上位机开发工程师中级上位机开发工程师高级上位机开发工程师怎么划分
03-29
初级上位机开发工程师：需要具备基本的上位机开发技能，能够独立完成简单的上位机软件开发任务，熟悉常见的上位机通信协议和界面设计，能够对上位机软件进行简单的维护和升级。 中级上位机开发工程师：需要具备较高的上位机开发技能，能够独立完成复杂的上位机软件开发任务，具备一定的软件架构设计能力，能够处理一些复杂的上位机通信问题和界面设计问题，能够对上位机软件进行较为深入的维护和升级。 高级上位机开发工程师：需要具备非常高的上位机开发技能，能够独立完成非常复杂的上位机软件开发任务，具备较强的软件架构设计能力和优化能力，能够解决各种复杂的上位机通信和界面设计问题，能够对上位机软件进行非常深入的维护和升级，并具备一定的团队管理和技术指导能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值