(CircularBuffer) c++环形缓冲区

最新推荐文章于 2025-04-08 20:57:18 发布
最新推荐文章于 2025-04-08 20:57:18 发布
阅读量911 收藏 9
点赞数 1
文章标签： 网络 c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_64660649/article/details/132573816
版权

本说明涉及如下内容

        1. 什么是环形缓冲区

        2. 如何实现环形缓冲区

什么是环形缓冲区

环形缓冲区是一个先进先出（FIFO）的闭环的存储空间，可等效为首尾相连的队列。可类比为在内存中规划了一个水轮车（环形缓冲区），将水装载到轮子一侧的格子（将数据保存在缓冲区内存内），通过轮子的转动便可实现水（数据）在不同的水道（线程）内进行传输，从而实现数据在线程间的零拷贝传输。

        ps. 因进程间会有各自独立的堆区，所以环形缓冲区无法实现进程间通讯。

如何实现环形缓冲区

一. 定义类成员变量

        1. 为了方便项目使用，本套环形缓冲区采用泛型设计，定义待处理数据类型为DATA

template <typename DATA>

        2.  定义保存数据的数组

std::vector<DATA> data;

        3. 因为环形缓冲区在不同的线程间运作，故需要设计线程管理

/**
 * @brief 读锁
*/
std::mutex m_read_lock;

/**
 * @brief 写锁
*/
std::mutex m_write_lock;

/**
 * @brief 用于避免空数据处理的条件变量
*/
std::condition_variable m_cv;

        4. 定义缓冲区大小变量

/**
 * @brief 缓冲区最大尺寸
*/
int max_size;


/**
 * @brief 缓冲区现存数据量
*/
int count;

        5. 定义缓冲区读写头

/**
 * @brief 读头
*/
int head;

/**
 * @brief 写头
*/
int end;

        6. 定义缓冲区工作状态标识

bool is_working = false;

二. 定义缓冲区数据情况函数

/**
 * @brief determine whether the buffer is empty
 *
 * @return true  : no data in buffer
 * @return false : buffer has data
 */
bool is_empty()
{
    if (this->count == 0)
    {
        return true;
    }
    return false;
}

/**
 * @brief is the buffer full
 *
 * @return true  : full
 * @return false : dissatisfaction
 */
bool is_full()
{
    if (this->count == this->max_size)
    {
        return true;
    }
    return false;
}

三. 定义缓冲区构造函数

/**
 * @brief Construct a new Circular Buffer object
 *
 * @param size : buffer size
 */
CircularBuffer(int size)
{
    // 对缓冲区进行上锁，避免误操作
    std::unique_lock<std::mutex> lock_w(this->m_write_lock);
    std::unique_lock<std::mutex> lock_r(this->m_read_lock);

    // 设置缓冲区尺寸
    if (size <= 0)
    {
        Log_ERROR << "Buffer size must be greater than 0" << Log_END;
    }
    else
    {
        // 缓冲区预分配内存（通过此操作，避免std::vector重新分配内存，导致性能降低）
        this->data.reserve(size);

        // 正式为缓冲区分配内存
        for (int i = 0; i < size; i++)
        {
            DATA process;
            this->data.emplace_back(process);
        }

        // 缓冲区各成员变量初始化
        this->max_size = size;
        this->count = 0;
        this->head = 0;
        this->end = 0;
        this->is_working = true;
    }
}

四. 定义缓冲区数据量处理函数

/**
 * @brief Get the Data Size object
 * 
 * @return int 
 */
int getDataSize()
{
    std::unique_lock<std::mutex> lock_w(this->m_write_lock);
    std::unique_lock<std::mutex> lock_r(this->m_read_lock);

    if (this->is_working == false)
    {
        return -1;
    }

    return this->count;
}

/**
 * @brief clear buffer
 * 
 * @return true  : clear successfully
 * @return false : empty failed
 */
bool clearBuffer()
{
    std::unique_lock<std::mutex> lock_w(this->m_write_lock);
    std::unique_lock<std::mutex> lock_r(this->m_read_lock);

    if (this->is_working == false)
    {
        Log_ERROR << "the buffer has not started working" << Log_END;
        return false;
    }

    this->count = 0;
    this->head = 0;
    this->end = 0;

    return true;
}

/**
 * @brief Get the Max size object
 * 
 * @return int 
 */
int getMax_size()
{
    return this->max_size;
}

五. 数据插入函数

/**
 * @brief insert data into the buffer
 * 
 * @param data   : data to be added
 * @return true  : successfully added
 * @return false : add failed
 */
bool insert(DATA data)
{
    if (this->is_working == false)
    {
        return false;
    }

    std::unique_lock<std::mutex> lock(this->m_write_lock);

    // 等待缓冲区有剩余空间，没有则在这里进行阻塞
    this->m_cv.wait(lock, [this]
                    { return this->is_full() == false; });

    try
    {
        this->data[this->end] = data;
        this->end = (this->end + 1) % this->max_size;
        ++this->count;
    }
    catch (const std::exception &e)
    {
        Log_ERROR << e.what() << Log_END;
    }

    lock.unlock();
    this->m_cv.notify_one();

    return true;
}

六. 数据弹出函数

/**
 * @brief eject data from buffer
 * 
 * @param data   : container for receiving pop up data
 * @return true  : eject successfully
 * @return false : eject failed
 */
bool eject(DATA &data)
{
    if (this->is_working == false)
    {
        return false;
    }

    std::unique_lock<std::mutex> lock(this->m_read_lock);

    this->m_cv.wait(lock, [this]
                    { return this->is_empty() == false; });

    try
    {
        data = this->data[this->head];
        this->head = (this->head + 1) % this->max_size;
        --this->count;
    }
    catch (const std::exception &e)
    {
        Log_ERROR << e.what() << Log_END;
    }

    lock.unlock();
    this->m_cv.notify_one();
    return true;
}

完整代码

#pragma once

/**
 * @file CircularBuffer.hpp
 * @author jiyilin 2474803745@qq.com
 * @brief this is a program for creating and using multithreaded circular buffer
 * @version 0.1
 * @date 2023-07-26
 *
 * @copyright Copyright (c) 2023
 *
 */

#include "log_system/LoggingSystem.h"
#include <condition_variable>
#include <mutex>
#include <vector>
#include <chrono>
#include <thread>

namespace Memory
{
    /**
     * @brief this class is used to use ring buffers
     *
     * @tparam DATA data
     *
     * @memberof data              : ring buffer for saving data
     * @memberof m_read_lock       : read lock
     * @memberof m_write_lock      : write lock
     *
     * @memberof m_cv              : condition variable to determine whether reading and writing can continue
     *
     * @memberof max_size          : maximum value
     * @memberof count             : existing data volume
     * @memberof head              : buffer read header
     * @memberof end               : buffer write header
     * @memberof is_working        : identification of whether the buffer works normally
     */
    template <typename DATA>
    class CircularBuffer
    {
    private:
        std::vector<DATA> data;

        std::mutex m_read_lock;
        std::mutex m_write_lock;

        std::condition_variable m_cv;

        int max_size;

        int count;

        int head;

        int end;

        bool is_working = false;

    private:
        /**
         * @brief determine whether the buffer is empty
         *
         * @return true  : no data in buffer
         * @return false : buffer has data
         */
        bool is_empty()
        {
            if (this->count == 0)
            {
                return true;
            }
            return false;
        }

        /**
         * @brief is the buffer full
         *
         * @return true  : full
         * @return false : dissatisfaction
         */
        bool is_full()
        {
            if (this->count == this->max_size)
            {
                return true;
            }
            return false;
        }

    public:
        /**
         * @brief Construct a new Circular Buffer object
         *
         * @param size : buffer size
         */
        CircularBuffer(int size)
        {
            std::unique_lock<std::mutex> lock_w(this->m_write_lock);
            std::unique_lock<std::mutex> lock_r(this->m_read_lock);

            if (size <= 0)
            {
                Log_ERROR << "Buffer size must be greater than 0" << Log_END;
            }
            else
            {
                this->data.reserve(size);
                for (int i = 0; i < size; i++)
                {
                    DATA process;
                    this->data.emplace_back(process);
                }

                this->max_size = size;
                this->count = 0;
                this->head = 0;
                this->end = 0;
                this->is_working = true;
            }
        }

        /**
         * @brief Get the Data Size object
         * 
         * @return int 
         */
        int getDataSize()
        {
            std::unique_lock<std::mutex> lock_w(this->m_write_lock);
            std::unique_lock<std::mutex> lock_r(this->m_read_lock);

            if (this->is_working == false)
            {
                return -1;
            }

            return this->count;
        }

        /**
         * @brief clear buffer
         * 
         * @return true  : clear successfully
         * @return false : empty failed
         */
        bool clearBuffer()
        {
            std::unique_lock<std::mutex> lock_w(this->m_write_lock);
            std::unique_lock<std::mutex> lock_r(this->m_read_lock);

            if (this->is_working == false)
            {
                Log_ERROR << "the buffer has not started working" << Log_END;
                return false;
            }

            this->count = 0;
            this->head = 0;
            this->end = 0;

            return true;
        }

        /**
         * @brief Get the Max size object
         * 
         * @return int 
         */
        int getMax_size()
        {
            return this->max_size;
        }

        /**
         * @brief insert data into the buffer
         * 
         * @param data   : data to be added
         * @return true  : successfully added
         * @return false : add failed
         */
        bool insert(DATA data)
        {
            std::unique_lock<std::mutex> lock(this->m_write_lock);

            if (this->is_working == false)
            {
                return false;
            }

            this->m_cv.wait(lock, [this]
                            { return this->is_full() == false; });

            try
            {
                this->data[this->end] = data;
                this->end = (this->end + 1) % this->max_size;
                ++this->count;
            }
            catch (const std::exception &e)
            {
                Log_ERROR << e.what() << Log_END;
            }

            lock.unlock();
            this->m_cv.notify_one();

            return true;
        }

        /**
         * @brief eject data from buffer
         * 
         * @param data   : container for receiving pop up data
         * @return true  : eject successfully
         * @return false : eject failed
         */
        bool eject(DATA &data)
        {
            std::unique_lock<std::mutex> lock(this->m_read_lock);

            if (this->is_working == false)
            {
                return false;
            }

            this->m_cv.wait(lock, [this]
                            { return this->is_empty() == false; });

            try
            {
                data = this->data[this->head];
                this->head = (this->head + 1) % this->max_size;
                --this->count;
            }
            catch (const std::exception &e)
            {
                Log_ERROR << e.what() << Log_END;
            }

            lock.unlock();
            this->m_cv.notify_one();
            return true;
        }

        /**
         * @brief Destroy the Circular Buffer object
         * 
         */
        ~CircularBuffer(){};
    };
} // namespace Memory

调用demo

# include "log_system/LoggingSystem.h"
# include "CircularBuffer/CircularBuffer.hpp"

void WriteThread(Memory::CircularBuffer<int *> *buffer)
{
    for (int i = 0; i < 100; i++)
    {
        int *process = new int;
        *process = i;
        buffer->insert(process);
    }
}

void TestThread(Memory::CircularBuffer<int *> *buffer)
{
    while (true)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
        if (buffer->getDataSize() != 0)
        {
            std::cout << "buffer size = " << buffer->getDataSize() << std::endl;
        }
        
    }
}

int main()
{
    Memory::CircularBuffer<int *> buffer(10);

    std::thread writeThreader(WriteThread, &buffer);

    std::thread testThreader(TestThread, &buffer);

    int *output;
    while (true)
    {
        if (buffer.eject(output) == true)
        {
            std::cout << *output << std::endl;
        }
    }

    return 0;
}

纪亦林
关注
通用循环缓冲区类(c++版)
程序猿老樊的博客
05-12 889
在多种应用场景下，如网络通信、数据流处理和实时系统中，循环缓冲区（又称环形缓冲区、圆形缓冲区或者循环队列）是一个非常有用的数据结构。它允许缓冲区在被填满之后，自动从起始位置开始重写数据，从而实现一个连续的数据流处理。本文将介绍如何在C++中实现一个通用的循环缓冲区类（），并确保其高效性和类型安全性。
C++环形缓冲区
weiyu00的博客
12-03 1176
#pragma once template &amp;amp;amp;amp;amp;lt;class T&amp;amp;amp;amp;amp;gt; class CRingBuffer { public: CRingBuffer() { m_pBuffer = NULL; m_nSize = 0; m_nUnreadSize = 0; m_nWritePos = 0; m_nReadPos = 0; } virtual ~
一个c++环形队列缓冲区
11-30
环形缓冲区读写操作的分析与实现，以及在并发条件下如何控制竞争
环形缓冲区类（C++源码）绝对可用
flyingleo1981的专栏
01-22 5201
参考网络循环缓冲区类源码，修改了作者的两个bug，经测试，可以实现多线程并发读写。数据准确无误。 多线程并行读写环形缓冲区源代码例子 代码例子下载：环形缓冲区VC+Qt的项目代码 理论如下：   源码如下： //环形缓冲区头文件#ifndef CCycleBuffer_H #define CCycleBuffer_H class CCycleBuffer { pu
C++实现环形缓冲区
最新发布
qq_56402998的博客
04-08 888
public:// 类型定义 (STL容器要求)提供STL容器标准接口所需的类型定义支持自定义分配器（默认使用std::allocator）template <typename T, typename Allocator = std::allocator<T>>：这是一个模板声明。T是一个模板类型参数，代表环形缓冲区中存储的元素类型。Allocator是另一个模板类型参数，它代表用于分配和释放内存的分配器类型，默认使用std::allocator<T>，这是标准库中提供的通用分配器。
C++ 环形缓冲区（队列）简单实现
thequitesunshine007的博客
10-25 2914
1. 说明 在实际工作中，如果数据流量过大，可以先把数据接收到数据缓冲区中，处理之后再取出。我们定义的包协议可以采用定长包，可以采用不定长度的包，环形缓冲区都能处理。 2. 使用场景 2.1 生产消费的场所 在 “生产者--消费者”模式中，往往会用到这种环形缓冲区的功能。 2.2 线程间高速通信的场所 3. 使用的局限性 主要适用于单向传输。不太适用于双向传输的情形。 4. 代码展示 CircleBuffer.h #pragma once # include <stdint.h&
一个封装好的C++环形缓冲区
11-30
环形缓冲区（Circular Buffer），又称循环队列，是一种数据结构，通常用于实现高效的缓存机制。它在一个固定大小的数组中进行操作，当缓冲区满时，新的元素会覆盖最旧的元素，而不是像传统缓冲区那样等待空间释放。...
Circular_Buffer:循环缓冲区循环数组
05-25
该库支持的缓冲区系统不仅仅用于环形缓冲区。 有一个功能更强大的阵列系统。 两种缓冲区类型都有其自己的高级功能集，我们将讨论它们。 圆环缓冲器的方法 void print(const char *p); void println(const char *p...
基于C++的环形缓冲区.zip
09-01
环形缓冲区（Circular Buffer）又称为循环缓冲区，是一个在内存中预先分配好的一块连续空间，其特点是头部和尾部在缓冲区满时会相遇并重新开始，形成一个环状结构。这种数据结构允许高效地进行读写操作，因为它们...
C++环形缓冲区模板代码
11-30
一个C++缓冲区模板类,循环队列实现，循环法抛弃最先进缓冲区的数据
环形缓冲区
11-07
环形缓冲区的优点就不赘述了，此VS2015工程封装好环形缓冲区的接口，Boost库的二次封装，有测试示例。如果有编译问题，选择x86编译，记得要配置boost库环境。PS：如果可以的话，大量使用boost库，用起来很方便。
C/C++实现环形缓冲
weixin_34080951的博客
12-03 464
在开发过程中经常会遇到需要使用环形缓冲的地方，比如在流媒体方面，对于接收到的音视频数据的存储、以及音频解码后PCM数据的存储等问题上，最好使用一个环形缓冲，接收到，或者解码后压入该缓冲区中，在需要解码，或者需要塞入声卡时，再从该缓冲区中读取，这样压入和取出同一个缓冲区，既方便快捷，又安全有效。源码如下：typedefchars8; typedefunsigned...
C++——一个封装好的环形缓冲区
05-14 1038
/*------------------------- 002  * Author: XadillaX       | 003  * Data: 2010/10/3        | 004  * Class: CircleBuffer    |
c++ 环形缓冲区（RingBuffer）
www_dong的博客
12-03 767
环形缓冲区（Circular Buffer）与环形队列类似，是一种数据结构，支持在固定容量下的高效读写操作。相比队列，环形缓冲区通常允许覆盖旧数据，这在某些场景（如实时数据流、日志处理）中非常有用。
2021-09-13嵌入式学习笔记--基于C++的环形缓冲区demo
jeason的博客
09-16 496
最近学习了韦东山老师的RTOS训练营相关的知识后想自己实现一下环形缓冲区，具体的实现如下： 注意： 缓冲区的大小要比实际的小一个！ 我也是查了半天才知道的！ 代码中对于未使用的空间写入了 -1 主要是方便查看，如果实际的应用中可以去掉 这一步 降低资源开销 // circleBuffer.h #ifndef _CIRCLE_BUFFER_H_ #define _CIRCLE_BUFFER_H_ #include <stdio.h> #include <cstdio> #in
C++环形缓冲区的简单实现
04-03 2741
分享一个在工作中用到的简单的环形缓冲区。构造简单，可以改造到Qt中使用，也可以直接在VS下使用。 所谓环形缓冲区，其实就是带有标识缓冲区中数据头、尾位置的缓冲区，这个缓冲区根据业务的不同，要设置的稍微大一点，不能一有数据过来就填满了，这样就失去使用的意义了。 在实际工作中，我们使用TCP和设备进行通信，如果数据流量过大，可以先把数据接收到数据缓冲区中，处理之后再取出。我们定义的包协议可以采用定...
深入解析CircleBuffer：环形缓冲区的优势与应用
环形缓冲区（Circular Buffer），又称为循环缓冲区、环状缓冲区或圆环缓冲区，是一种在计算机科学中用于存储数据的缓冲区结构。它具有先进先出（FIFO）的特性，用于管理固定大小的数据流，允许在删除已处理的数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值