高性能环形缓冲区设计

最新推荐文章于 2024-04-19 10:05:16 发布
最新推荐文章于 2024-04-19 10:05:16 发布
阅读量374 收藏
点赞数
分类专栏： # 数据结构 文章标签： c++ 算法 缓冲区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44519484/article/details/118766189
版权

来源：微信公众号「编程学习基地」

文章目录

绪论

设计缘由

工作后第一个项目是实现一个数据转发服务器，将视频数据通过websocket转发给手机app端。

第一次在需要考虑网络因素，需要设计一个消息缓冲队列，用于存储大量数据。领导建议我利用环形缓冲区替换链式缓冲区减少memmove的次数，提高服务器性能。

为什么要设计环形缓冲区

目的：避免频繁的内存创建取消、分配，移动以提高服务器性能。内存一直只用了一块。

环形缓冲区的实现原理

环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。

图1、图2和图3是一个环形缓冲区的运行示意图。图1是环形缓冲区的初始状态，可以看到读指针和写指针都指向第一个缓冲区处；图2是向环形缓冲区中添加了一个数据后的情况，可以看到写指针已经移动到数据块2的位置，而读指针没有移动；图3是环形缓冲区进行了读取和添加后的状态，可以看到环形缓冲区中已经添加了两个数据，已经读取了一个数据。

img

判断“空”和“满”

上述的操作并不复杂，不过有一个小小的麻烦：空环和满环的时候，R和W都指向同一个位置！这样就无法判断到底是“空”还是“满”。

大体上有两种方法可以解决该问题。
办法1：始终保持一个元素不用
　　当空环的时候，R和W重叠。当W比R跑得快，追到距离R还有一个元素间隔的时候，就认为环已经满。当环内元素占用的存储空间较大的时候，这种办法显得很土（浪费空间）。
办法2：维护额外变量
　　如果不喜欢上述办法，还可以采用额外的变量来解决。比如可以用一个整数记录当前环中已经保存的元素个数（该整数>=0）。当R和W重叠的时候，通过该变量就可以知道是“空”还是“满”。

环形缓冲区设计分两种模式

模式一

写入读取数据，不考虑读取数据的长度，读取数据的顺序为写入数据的顺序

环形缓冲区测试代码
#include "lwsBuffer.h"
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
    char dataBuf[1024];
    void *temp = NULL;
    int readFd = open("lwsBuffer.cpp", O_RDONLY);
    int writeFd = open("temp.cpp", O_WRONLY | O_CREAT);

    int ret;
    memset(dataBuf, '\0', 1024);
    lwsBuffer Buff;
    while (1)
    {
        /* code */
        memset(dataBuf, '\0', sizeof(dataBuf));
        ret = read(readFd, dataBuf, sizeof(dataBuf));
        if (ret == 0)
        {
            printf("read end..");
            break;
        }
        else if (ret < 0)
            printf("read error ret:%d", ret);
        else
            printf("read  ret:%d\n", ret);
        ret = Buff.write(dataBuf, ret); //将 dataBuf 数据写入到Buff缓冲区
        printf("write ret:%d\n", ret);
    }
    printf("\n\ncurrent Buff total len:%d\n\n", Buff.getTotalLen());
    while (1)
    {
        char tempBuf[1024];
        memset(tempBuf,'\0',sizeof(tempBuf));
        ret = Buff.read(&temp); //从 Buff缓冲区中读取数据
        if (ret == -1)
            break;
        memmove(tempBuf, temp, ret);
        /* code */
        printf("total len:%d\n", Buff.getTotalLen());
        write(writeFd, tempBuf, ret);
    }

    close(readFd);
    close(writeFd);
    return 0;
}
makefile编译文件
test:test.cpp
	g++ -o test test.cpp lwsBuffer.cpp 
.PHONY:clean
clean:
	rm -f test temp.cpp
运行结果
sh-4.3$ make
g++ -o test test.cpp lwsBuffer.cpp 
sh-4.3$ ls
lwsBuffer.cpp  lwsBuffer.h  makefile  test  test.cpp
sh-4.3$ ./test 
read  ret:1024
write ret:1024
read  ret:1024
write ret:1024
read  ret:1024
write ret:1024
read  ret:964
write ret:964
read end..

current Buff total len:4036

total len:3012
total len:1988
total len:964
total len:0
sh-4.3$ ls
lwsBuffer.cpp  lwsBuffer.h  makefile  temp.cpp  test  test.cpp

执行后结果就是读取 lwsBuffer.cpp 里面的数据，储存到环形缓冲区，再从环形缓冲区读取数据写入到 temp.cpp

应用场景和优缺点

大量数据的转发

优点：牺牲少量内存实现最少的数据拷贝memmove

缺点：当转发的数据很大时，没一个对象浪费的内存在转发的数据大小之内

​ 当读取数据缓慢的时候会造成频繁的内存重分配，缓冲区变得越来越大。

lwsBuffer.h
#pragma once

#ifndef _LWS_BUFFER_H_
#define _LWS_BUFFER_H_
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <list>
#define BUFFER_SIZE 1024
class lwsBuffer
{
private:
    /* data */
    void* buffer;               /* 数据 */
    size_t bufMaxSize;          /* 最大的存储数据大小 */
    size_t rightWritePos;
    int readpos,writepos;       /* 读写位置 */

    size_t totalLen;            /* 存储的数据大小 */
    std::list<int> lenList;     /* 数据长度的链表 */
public:
    lwsBuffer(/* args */);
    ~lwsBuffer();
public:
    int write(void *data, int dataLen);
    int read(void** data);
    int getTotalLen();
protected:
    int writeAfter(void* data, int dataLen);
    int writePre(void* data, int dataLen);
    void _remalloc();
};
#endif
lwsBuffer.cpp
#include "lwsBuffer.h"

lwsBuffer::lwsBuffer(/* args */)
{
    this->readpos = 0;
    this->writepos = 0;
    this->rightWritePos = 0;
    this->bufMaxSize = BUFFER_SIZE;
    this->buffer = malloc(this->bufMaxSize);

    this->totalLen = 0;
    this->lenList.clear();
}

lwsBuffer::~lwsBuffer()
{
    if (buffer)
        free(buffer);
}

int lwsBuffer::write(void *data, int dataLen)
{
    int ret = -1;
    if (dataLen <= 0 || data == NULL)
        return ret;

    /* writePos 在 readPos 前 / readPos == writePos push*/
    if (this->writepos >= this->readpos)
    {
        ret = writePre(data, dataLen);
    }
    /* readPos 在 writePos 前  push*/
    else if(this->writepos < this->readpos)
    {
        ret = writeAfter(data, dataLen);
    }
    return ret;
}

int lwsBuffer::writePre(void* data, int dataLen)
{
    int ret = -1;
    /*  写入位置在前  */
    /*  buffer 后面有空间可以写入数据*/
    if ((this->writepos + dataLen) <= this->bufMaxSize) 
    {
        //将数据写入到 buffer 里面去
        memmove((char *)this->buffer + this->writepos, data, dataLen);
        /* 修改 writepos 偏移 */
        this->writepos = this->writepos + dataLen;
        /* 计算数据长度*/
        lenList.push_back(dataLen);
        totalLen += dataLen;
        ret = dataLen;
    }
    else
    {
        /*  buffer 后面没有空间可以写入数据  记录下罪*/
        this->rightWritePos = this->writepos;
        /* 修改 writepos 偏移 */
        this->writepos = 0;
        ret = writeAfter(data, dataLen);
    }
    return ret;
}

int lwsBuffer::writeAfter(void *data, int dataLen)
{
    int ret = -1;
    /*  写入位置在后  */
    /*  writepos 到 readpos 有足够的空间可以写入数据  */
    if ((this->writepos + dataLen) < this->readpos)
    {
        //将数据写入到 buffer 里面去
        memmove((char *)this->buffer + this->writepos, data, dataLen);
        /* 修改 writepos 偏移 */
        this->writepos = this->writepos + dataLen;
        /* 计算数据长度*/
        lenList.push_back(dataLen);
        totalLen += dataLen;
        ret = dataLen;
    }
    else
    {
        this->_remalloc();
        ret = writePre(data, dataLen);
    }
    return ret;
}

void lwsBuffer::_remalloc()
{
    /*  数据满了 */
    void *newBuf = malloc(this->bufMaxSize + BUFFER_SIZE / 2);
    /*      */
    memmove(newBuf, (char*)this->buffer + this->readpos, this->rightWritePos - this->readpos);
    memmove((char*)newBuf + this->rightWritePos - this->readpos, this->buffer, this->writepos);
    free(this->buffer);
    this->buffer = newBuf;

    this->writepos = this->rightWritePos - this->readpos + this->writepos;
    this->readpos = 0;
    this->bufMaxSize = this->bufMaxSize + BUFFER_SIZE / 2;
    // printf("buffMaxSize:%d, totalLen:%d ,list size:%d\n", (int)this->bufMaxSize, (int)this->totalLen, (int)lenList.size());
}

int lwsBuffer::read(void** data)
{
    int ret = -1;
    if (this->totalLen > 0)
    {
        int dataLen = lenList.front();
        if((this->readpos + dataLen) <= this->bufMaxSize)
        {
            (*data) = (char *)this->buffer + this->readpos;
            // printf("\n读取位置: %d ,读取信息 len: %d, data:%s\n", this->readpos, dataLen, (char*)data);
            /* 修改 writepos 偏移 */
            this->readpos += dataLen;
            /* 计算数据长度*/
            this->totalLen -= dataLen;
            lenList.pop_front();
            ret = dataLen;
        }
        else{
            printf("从头开始读取\n");
            this->readpos = 0;
            (*data) = (char *)this->buffer + this->readpos;

            // printf("\n读取位置: %d ,读取信息 len：%d, data:%s\n", this->readpos, dataLen, (char*)data);
            this->readpos += dataLen;
            /* 计算数据长度*/
            this->totalLen -= dataLen;
            lenList.pop_front();
            ret = dataLen;
        }
    }
    return ret;
}

int lwsBuffer::getTotalLen()
{
    return this->totalLen;
}

模式二

写入读取数据，写入指定长度数据，和读取指定长度数据，模仿QBuffer的读写功能

环形缓冲区测试代码
#include "lwsBuffer.h"
#include<stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
    char buf[1024],temp[1024];
    int readFd = open("lwsBuffer.cpp",O_RDONLY);
    int writeFd = open("temp.cpp",O_WRONLY|O_CREAT,0666);
    
    int ret;
    memset(buf, '\0', 1024);
    memset(temp, '\0', 1024);
    lwsBuffer Buff;
    while (1)
    {
        /* code */
        ret = read(readFd, buf, sizeof(buf));
        if (ret == 0)
            break;
        int dataLen = Buff.write(buf,ret);  //将数据保存到环形缓冲区
        memset(buf, '\0', 1024);
        printf("dataLen:%d\n",dataLen);
    }

    while(1)
    {
        memset(temp,'\0',sizeof(temp));
        ret = Buff.read(temp, 1024);    //从环形缓冲区中读取数据
        if (ret == -1)
            break;
        /* code */
        ret = write(writeFd, temp, ret);
        printf("write ret:%d\n", ret);
    }

    close(readFd);
    close(writeFd);
    return 0;
}
makefile编译文件
test:test.cpp
	g++ -o test test.cpp lwsBuffer.cpp 
.PHONY:clean
clean:
	rm -f test temp.cpp
运行结果
sh-4.3$ make
g++ -o test test.cpp lwsBuffer.cpp 
sh-4.3$ ./test 
dataLen:1024
dataLen:1024
dataLen:1024
dataLen:766
write ret:1024
write ret:1024
write ret:1024
write ret:766
应用场景和优缺点

适用于少量数据的频繁读写

优点：多次memmove实现占空间最少的快速读写

缺点：当转发的数据很大且很频繁时，多次memmove会导致性能的减少

lwsBuffer.h
#pragma once

#ifndef _LWS_BUFFER_H_
#define _LWS_BUFFER_H_
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define BUFFER_SIZE 1024
class lwsBuffer
{
private:
    /* data */
    void* buffer;               /*数据*/
    size_t bufMaxSize;          /* 最大的存储数据大小 */
    size_t bufLen;              /* 存储的数据大小 */
    int readpos,writepos;       /* 读写位置 */
public:
    lwsBuffer(/* args */);
    ~lwsBuffer();
public:
    int write(void *data, int dataLen);
    int read(void *data, int dataLen);

protected:
    int writeAfter(void* data, int dataLen);
    int writePre(void* data, int dataLen);
    void _remalloc();
};

#endif
lwsBuffer.cpp
#include "lwsBuffer.h"

lwsBuffer::lwsBuffer(/* args */)
{
    this->readpos = 0;
    this->writepos = 0;
    this->bufLen = 0;
    this->bufMaxSize = BUFFER_SIZE;
    this->buffer = malloc(this->bufMaxSize);
}

lwsBuffer::~lwsBuffer()
{
    if (buffer)
        free(buffer);
}

int lwsBuffer::write(void *data, int dataLen)
{
    int ret = -1;
    /* writePos 在 readPos 前 / readPos == writePos push*/
    if (this->writepos >= this->readpos)
    {
        ret = writePre(data, dataLen);
    }
    /* readPos 在 writePos 前  push*/
    else if(this->writepos < this->readpos)
    {
        ret = writeAfter(data, dataLen);
    }
    return ret;
}

int lwsBuffer::writePre(void* data, int dataLen)
{
    int ret = -1;
    /*  写入位置在前  */
    /*  buffer 后面有空间可以写入数据  预留一个字节不存储数据，用于区分*/
    if ((this->writepos + dataLen) <= this->bufMaxSize)
    {
        //将数据写入到 buffer 里面去
        memmove((char *)this->buffer + this->writepos, data, dataLen);
        // printf("即将 push %d 消息 on:%d :%s\n", dataLen, prod->writepos, (char *)prod->buffer + prod->writepos + LWS_PRE);
        this->writepos = this->writepos + dataLen;
        ret = dataLen;
        bufLen += dataLen;
    }
    else
    {
        /*  buffer 后面没有空间可以写入数据  记录下*/
        int temp = this->bufMaxSize - this->writepos;
        temp = writePre(data, temp);
        this->writepos = 0;
        ret = writeAfter((char*)data + temp, dataLen - temp) + temp;
    }
    return ret;
}

int lwsBuffer::writeAfter(void *data, int dataLen)
{
    int ret = -1;
    /*  写入位置在后  */
    /*  writepos 到 readpos 有足够的空间可以写入数据  */
    if ((this->writepos + dataLen) < this->readpos)
    {
        //将数据写入到 buffer 里面去
        memmove((char *)this->buffer + this->writepos, data, dataLen);
        this->writepos = this->writepos + dataLen;
        ret = dataLen;
        bufLen += dataLen;
    }
    else
    {
        this->_remalloc();
        ret = writePre(data, dataLen);
    }
    return ret;
}

void lwsBuffer::_remalloc()
{
    /*  数据满了 */
    void *newBuf = malloc(this->bufMaxSize + BUFFER_SIZE / 2);
    /*      */
    memmove(newBuf, (char*)this->buffer + this->readpos, this->bufMaxSize - this->readpos);
    memmove((char*)newBuf + this->bufMaxSize - this->readpos, this->buffer, this->writepos);
    free(this->buffer);
    this->buffer = newBuf;

    this->writepos = this->bufMaxSize - this->readpos + this->writepos;
    this->readpos = 0;
    this->bufMaxSize = this->bufMaxSize + BUFFER_SIZE / 2;
    // printf("buffMaxSize:%d, bufLen:%d\n", (int)this->bufMaxSize,(int)this->bufLen);
}

int lwsBuffer::read(void *data, int dataLen)
{
    int ret = -1;
    if (this->bufLen > 0)
    {
        if (dataLen > this->bufLen)
        {
            dataLen = this->bufLen;
        }
        if ((this->readpos + dataLen) <= this->bufMaxSize)
        {
            memmove(data, (char *)this->buffer + this->readpos, dataLen);
            // printf("\n读取位置: %d ,读取信息 len：%d,data:%s\n", this->readpos, dataLen, (char *)data);
            this->readpos += dataLen;
            this->bufLen -= dataLen;
            ret = dataLen;
        }
        else
        {
            int temp = this->bufMaxSize - this->readpos;
            temp = read(data, temp);
            this->readpos = 0;
            
            memmove((char*)data + temp, (char *)this->buffer, dataLen - temp);
            // printf("\n读取位置: %d ,读取信息 len：%d, data:%s\n", this->readpos, dataLen, (char *)data);
            this->readpos = this->readpos + dataLen - temp;
            this->bufLen = this->bufLen - (dataLen - temp);
            ret = dataLen;
        }
    }
    return ret;
}
DeRoy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
高速通信下环形缓冲区设计及实现
09-22
1.高速通信下，环形缓冲区设计及实现；可直接使用演示。 2.包括：服务端和客户端。说明：SOCKET通信非常简略，只为环形缓冲区测试使用，也适合初学都学习。 其他：里面包含SOCKET通信客户端/服务器演示，还包括了环形缓冲区现成的代码。
环形缓冲区的设计与实现
热门推荐
玩笑的博客
04-23 2万+
    环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在一个视频处理的机制中，环形缓冲区就可以理解为数据码流的通道，每一个通道都对应着一个环形缓冲区，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。    环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位
推荐开源项目：RMind's RingBuf - 高效内存缓冲区管理库
最新发布
gitblog_00068的博客
04-19 358
推荐开源项目：RMind's RingBuf - 高效内存缓冲区管理库 项目地址:https://gitcode.com/rmind/ringbuf 项目简介 RingBuf 是一个轻量级、高性能的环形缓冲区（Circular Buffer）实现，由 RMind 团队开发并开源。该项目的目标是为嵌入式系统和实时操作系统提供一种简单易用且高效的数据缓冲解决方案，同时也适用于其他需要处理动态数据流的应...
环形缓冲区设计
logens的专栏
06-13 237
流的处理很多地方都用到了环形缓冲区，其实就是开辟的一段内存区域，重复使用，有流经过时，就写入 里边，当前的写入点，可以是缓冲区中的任意一点，当然，此时读入点和写入点重合的话，表明此时的 缓冲区已被占满，流的尺寸太大。 class CCycleBuffer { public: bool isFull(); bool isEmpty(); void empty(); int getLeng...
RingBuffer_环形缓冲区_
10-02
4. 空间效率：环形缓冲区的空间利用率高，避免了传统队列可能存在的大量空闲空间问题。 在实际应用中，环形缓冲区广泛应用于以下场景： 1. 数据采集系统：例如，在音频和视频处理中，可以将采集到的数据实时存入...
环形缓冲区（RingBuffer）源码
07-22
这种设计模式在资源有限的嵌入式系统或高性能计算中尤为常见。 源码实测可用，意味着它已经经过了实际运行验证，具备较高的可靠性。这个环形缓冲区的实现包括以下几个关键功能： 1. **初始化函数**：初始化函数...
无锁 环形缓冲区
08-15
环形缓冲区（Circular Buffer）是一种线性数据结构，其设计灵感来源于计算机内存管理中的页表。它在内存中形成一个循环链，当数据从一端写入并从另一端读出时，可以有效地利用空间，避免了频繁地申请和释放内存。...
labview 环形缓冲区组件
02-29
LabVIEW是一款由美国国家仪器（NI）公司开发的图形化编程环境，专为测试、测量和控制应用设计。环形缓冲区组件是LabVIEW中一个非常...了解和熟练掌握环形缓冲区的使用，能够显著提升LabVIEW程序的设计水平和性能表现。
ghpringbuf:通用高性能环形缓冲区实现 - 跨平台，仅限 ANSI C
07-04
GHPRingBuf 是一个针对 ANSI C 语言实现的高性能、跨平台的环形缓冲区库。 GHPRingBuf 的设计主要考虑了以下关键特性： 1. **性能优化**：GHPRingBuf 通过精心设计的数据结构和算法，确保了在读写操作上的高效性。...
缓冲区分析设计与实现
12-04
可对数据进行缓冲区分析处理，设置相应半径，查看区域范围内的结果
如何设计一个高效的应用缓冲区【一个动态扩容的buffer类】
weixin_44545838的博客
10-01 453
在上一个博客，我们介绍到什么是缓冲区，然后也分析了epoll 两个模式使用阻塞与非阻塞缓冲区的区别。epoll与socket缓冲区的恩恩怨怨本文介绍如何设计一个合理的读写缓冲区。
顺序环形缓冲区的设计和实现
风叶
06-18 733
先放这里，有时间自己实现一个。
高性能缓存
snoweaglelord的博客
10-19 538
试用的场景: 读多写少的系统 需要经过复杂运算后得出的数据，存储系统无能为力，比如统计在线用户。 读多写少的数据，存储系统有心无力，比如微博，明星发一条，上千万浏览。 缓存穿透 缓存穿透是指缓存没有发挥作用，业务系统虽然去缓存查询数据，但缓存中没有数据，业务系统需要再次去存储系统查询数据。 存储数据不存在 缓存数据生成耗费大量时间或者资源 缓存雪崩 缓存雪崩是指当缓存失效（过期）...
环形缓冲区 -- circular buffer
qq51931373的专栏
06-26 5340
环形缓冲区有的地方也称之为环形队列。其实很多人都搞不懂环形缓冲区的本质，从而也就不知道在什么场景下应该使用环形缓冲区。当你了解了它的本质你就知道这玩意儿一点都不高级，而且由于它的本质在某些场景下还不能使用。我看了很多网络游戏服务器的源代码，有些源代码中大量使用这玩意儿。比如我打个比方： 在游戏服务器端只要接收到一个来自客户端的连接就生成一个ClientSocket对象来管理和客户端的数据通信。然
缓冲区设计—线程间通讯
海涛的专栏
08-10 4436
书接上回。 上一篇里，我们设计并实现了环形队列的数据结构。同时留下了下面的更具复杂性的问题： 对于push的操作，需要操作前等待队列已经有了空间，也就是说队列没有满的状态。等到这个状态出现了，才继续进行push的操作，否则，push操作挂起。 对于get 的操作，需要操作前等待队列有了数据，也就是说队列不为空的状态。等到这个状态出现了，才继续进行get的操作，否则，ge
服务器正文16：缓冲区设计（ringbuffer、用libevent配合ringbuffer做无锁队列）
谢白羽
06-06 846
文章目录一、为什么用户层需要设计网络缓冲区二、寿司ringbuffer以及多线程换将下数据安全思考三、libevent中event buffer的设计 一、为什么用户层需要设计网络缓冲区 二、寿司ringbuffer以及多线程换将下数据安全思考 三、libevent中event buffer的设计 https://www.bilibili.com/video/BV1ZL411M7Qz?spm_id_from=333.337.search-card.all.click ...............
缓冲的设计
xiaowenmu1的博客
05-17 296
本人实现了一个buffer，该buffer相当于一个环形缓冲区，添加数据时内部数据不需要挪动位置。该缓冲并没有实现缓冲的收缩功能以及对字节大小端的转换，如果需要稍微改进下就可以了。有兴趣的可以在GitHub上下载:https://github.com/xiaowenmu/buffer ...
stm32环形缓冲区
01-31
stm32环形缓冲区是一种用于数据传输和存储的数据结构。它由一段连续的内存空间组成，可分为两个部分：读指针和写指针。读指针用于读取数据，写指针用于写入数据。 环形缓冲区被设计成环形的形式，即当写指针超过缓冲区的末尾时，会自动回到缓冲区的开头。这样可以实现循环写入数据的功能。同样地，当读指针超过缓冲区的末尾时，它也会回到开头，实现循环读取数据的功能。 stm32环形缓冲区有几个重要的特点。首先，它可以高效地存储和传输大量的数据，特别适用于实时系统和数据传输要求高的应用。其次，它具有简单、高效的读写操作，可以实现快速的数据读写。第三，由于环形缓冲区的特殊设计，可以有效地解决内存溢出和数据丢失的问题。 stm32环形缓冲区在嵌入式系统中广泛应用，特别是在数据传输和存储方面。它可以用于串口通信、外设数据接收、数据采集和存储等场景。使用环形缓冲区可以提高系统的稳定性和可靠性，保证数据的完整性和准确性。 总之，stm32环形缓冲区是一种非常有用的数据结构，它在嵌入式系统中发挥着重要作用。通过合理的设计和使用，可以更好地实现数据的存储和传输，提高系统的性能和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

DeRoy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值