环形缓冲区(ring buffer)，环形队列(ring queue) 原理

已于 2024-08-22 14:00:04 修改
阅读量1.2w 收藏 16
点赞数 3
分类专栏： c-c++ 文章标签： java c++ jvm
于 2015-12-23 13:34:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wabil/article/details/50386446
版权

   环形缓冲区(ring buffer)，环形队列(ring queue) 多用于2个线程之间传递数据，是标准的先入先出(FIFO)模型。一般来说，对于多线程共享数据，需要使用mutex来同步，这样共享数据才不至于发生不可预测的修改/读取，然而，mutex的使用也带来了额外的系统开销，ring buffer/queue 的引入，就是为了有效地解决这个问题，因其特殊的结构及算法，可以用于2个线程中共享数据的同步，而且必须遵循A线程push in，B线程pull out的原则。采用这个机制另外一个用处是A push完数据后可以马上接收另外一个数据,当输入数据快速时不容易造成数据阻塞而丢包.

    当然基于这个模型还可以新增一些功能，如在push前加锁，就可以让多个线程来push数据。

线程 A                       媒介                        线程 B
data in --------> ring buffer/queue -------> data out

===============RingBuffer完整Python测试代码======================= 

class RingBuffer:
    def __init__(self, size_max):
        self.max = size_max + 1
        self.data = [None] * self.max
        self.wrPos = 0
        self.rdPos = 0

    def is_ringbuffer_full(self):
        if (self.wrPos + 1) % self.max == self.rdPos:
            return 1
        else:
            return 0

    def is_ringbuffer_empty(self):
        if self.wrPos == self.rdPos:
            return 1
        else:
            return 0

    # pop up data from rb
    def get(self):
        if self.is_ringbuffer_empty():
            return None
        ret = self.data[self.rdPos]
        self.rdPos = (self.rdPos + 1) % self.max
        return ret

    # push data to rb
    def append(self, item):
        if self.is_ringbuffer_full():
            return 0
        self.data[self.wrPos] = item
        self.wrPos = (self.wrPos + 1) % self.max
        return 1


if __name__ == "__main__":
    rb = RingBuffer(5)
    rb.append(1)
    rb.append(2)
    rb.append(3)
    rb.append(4)
    rb.append(5)
    rb.append(6)
    print(rb.get())  # 输出1
    print(rb.get())  # 输出2
    print(rb.get())  # 输出3
    print(rb.get())  # 输出4
    print(rb.get())  # 输出5
    print(rb.get())  # 输出None，因为buffer已经清空

    rb.append("Chinese")  # 重新push
    rb.append("English")
    rb.append("Franch")
    rb.append([10, 20, 30])

    print(rb.get())  # 输出 Chinse
    print(rb.get())  # 输出 English
    print(rb.get())  # 输出 Franch
    print(rb.get())  # 输出 [10,20,30]
    print(rb.get())  # 输出None，因为buffer已经清空


=============RingBuffer完整C测试代码[单元素]==========

#include <stdio.h>
#include <stdlib.h>
 
typedef struct TAG_RING_BUFFER
{
    int wrPos;
    int rdPos;
    int maxCount;
	int remainCnt;
    char *buffer;
	
} TagRingBuffer;
 
TagRingBuffer* ringBuffer_init(int size)
{
	 //Note: (size-1) is full!!
	TagRingBuffer * rb;
    rb = (TagRingBuffer*)malloc(sizeof(TagRingBuffer));
    if( rb == NULL)
    {
        return NULL;
    }
    rb->buffer = (char*)malloc( size );
    if( rb->buffer == NULL )
    {
        return 0;
    }
	rb->maxCount = size;
	rb->wrPos = 0;
	rb->rdPos = 0;
	rb->remainCnt = 0;
    return rb;
}
 
void ringBuffer_free(TagRingBuffer* rb)
{
	if( rb )
	{
		if(rb-> buffer)
		{
			free( rb-> buffer );
		}
		free( rb );
	}
}
 
int is_ringBuffer_full(TagRingBuffer* rb)
{
  //Note:(MAXCOUNT-1) is full!!
	if( ( (rb->wrPos)+1)%(rb->maxCount) == rb->rdPos )
	 return 1;
 
    return 0;
}
 
int is_ringBuffer_empty(TagRingBuffer* rb)
{
	if( (rb->wrPos) == rb->rdPos ){
	 return 1;
	}
 
    return 0;
}
 
int ringBuffer_pop(TagRingBuffer* rb,char *ch)
{  //read
	if( is_ringBuffer_empty(rb))
	{
		return 0;
	}
	*ch = rb->buffer[ rb->rdPos ];
	rb->rdPos =  (rb->rdPos +1)%rb->maxCount;
	rb->remainCnt --;
	return 1;
}
 
int ringBuffer_push(TagRingBuffer* rb,char ch)
{  //write
	if( is_ringBuffer_full(rb))
	{
		return 0;
	}
	rb->buffer[ rb->wrPos ] = ch;	
	rb->wrPos =  (rb->wrPos +1)%(rb->maxCount);
	rb->remainCnt++;
	return 1;
}

int ringBuffer_getRemainCnt(TagRingBuffer* rb)
{
	return rb->remainCnt;
}
 
 //RingBuffer 测试[单元素]
void main()
{
 
	printf("----C_BuildTime: %s----\r\n", __TIME__ );
	
   TagRingBuffer *rb ;
   char ch;
   int retn = 1;
   int remain = 0;
   
   rb = ringBuffer_init(5);
 
   ringBuffer_push(rb,1);
   ringBuffer_push(rb,3);  
   ringBuffer_push(rb,5); 
   ringBuffer_push(rb,7);//effect data
   
   ringBuffer_push(rb,9); //buffer is full
   ringBuffer_push(rb,11);
   ringBuffer_push(rb,13);
   ringBuffer_push(rb,15);
   
   
   for(int i=0;i<10;i++)
   { //测试超出ringbuffer范围的数据
	 ch = 0;
	 remain = ringBuffer_getRemainCnt(rb);
	 retn = ringBuffer_pop(rb,&ch);	 
	 printf("[%d] out_data=(%d),remain=%d,ret=%d.\n",i,ch,remain,retn  );   
   }	
}

=============RingQueue完整C测试代码[多元素]==========

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct TAG_RING_QUEUE
{
    int wrPos;
    int rdPos;
    int maxCount;
	int remainCnt;
    char**buffer;//storage address
	
} TagRingQueue;
 
TagRingQueue* ringQueue_init(int size)
{
	 //Note: (size-1) is full!!
	TagRingQueue * rb;
    rb = (TagRingQueue*)malloc(sizeof(TagRingQueue));
    if( rb == NULL)
    {
        return NULL;
    }
    rb->buffer = (char**)malloc( size* sizeof(char**) );
    if( rb->buffer == NULL )
    {
        return 0;
    }
	rb->maxCount = size;
	rb->wrPos = 0;
	rb->rdPos = 0;
	rb->remainCnt = 0;
    return rb;
}
 
void ringQueue_free(TagRingQueue* rb)
{
	if( rb )
	{
		if(rb-> buffer)
		{
			free( rb-> buffer );
		}
		free( rb );
	}
}

//首字节为长度数据
void ringQueue_free_pt(char*datPoint)
{
    if( (datPoint!=NULL) && ((datPoint-1)!=NULL))
    {
        free(datPoint-1);
    }
}
 
int is_ringQueue_full(TagRingQueue* rb)
{
  //Note:(MAXCOUNT-1) is full!!
	if( ( (rb->wrPos)+1)%(rb->maxCount) == rb->rdPos )
	 return 1;
 
    return 0;
}
 
int is_ringQueue_empty(TagRingQueue* rb)
{
	if( (rb->wrPos) == rb->rdPos ){
	 return 1;
	}
 
    return 0;
}
 
//注意:data前1节存数据长度,后面的数据才是本体 
//注意使用完后必须释放指针.
char* ringQueue_pop(TagRingQueue* rb,short *lenOut)
{  //read
    char *buff_pt = NULL;
	*lenOut = 0;
	if( is_ringQueue_empty(rb))
	{
		return NULL;
	}
	buff_pt = (char*)rb->buffer[ rb->rdPos ];
	rb->rdPos =  (rb->rdPos +1)%rb->maxCount;
	rb->remainCnt --;
	if( buff_pt != NULL)
	{
		*lenOut = *buff_pt;
		buff_pt++;
	}	
	return buff_pt;//must free after use! NOTE: free(buff_pt-1)
}
 
//注意:data前1字节存数据长度,后面的数据才是本体
int ringQueue_push(TagRingQueue* rb,char *data,short len)
{  //write
    char *buff_pt = NULL;
	if( is_ringQueue_full(rb))
	{
		return 0;
	}
	buff_pt = (char*)malloc(len+1);
	if( buff_pt == NULL )
	{
		return -1;//no mem
	}
	buff_pt[0] = len; //data第一字节存数据长度
	memcpy(buff_pt+1,data,len);
	rb->buffer[ rb->wrPos ] = buff_pt;	
	rb->wrPos =  (rb->wrPos +1)%(rb->maxCount);
	rb->remainCnt++;
	return 1;
}

int ringQueue_getRemainCnt(TagRingQueue* rb)
{
	return rb->remainCnt;
}
 
 
void dump_hex(char *infoStr,char *buf,int len)
{
	printf("%s(%d)",infoStr,len);
	for(int i=0;i<len;i++)
	{
		printf("%02X ",(unsigned char)buf[i]);
	}
	printf("\n");
} 
 
//RingQueue 测试 [多元素]
void main()
{
	printf("----C_BuildTime: %s----\r\n", __TIME__ );
	
   TagRingQueue *rb ;
   char data[50];   
   
   rb = ringQueue_init(5);//MAXCOUNT-1=4
 
   char rawDat[]={0x39,0x38,0x03,0x00,0x35,0x00,0x00};
   ringQueue_push(rb,rawDat,sizeof(rawDat)); //test raw data

   sprintf(data,"English");
   ringQueue_push(rb,data,strlen(data)+1);
   
   sprintf(data,"USA");
   ringQueue_push(rb,data,strlen(data)+1);    
   
   sprintf(data,"Japan");
   ringQueue_push(rb,data,strlen(data)+1);     
   
   sprintf(data,"India");
   ringQueue_push(rb,data,strlen(data)+1);   

   sprintf(data,"Yemen");
   ringQueue_push(rb,data,strlen(data)+1);   


   char* datOut = NULL;
   short lenOut = 0;

   
   for(int i=0;i<10;i++)
   { //测试超出ringQueue范围的数据
        datOut = ringQueue_pop(rb,&lenOut);
        printf("\n[%d] len_out=%d,data=[%s].",i,lenOut,datOut);
		dump_hex("HEX",datOut,lenOut);
        ringQueue_free_pt(datOut);//must free after use!!
 
   }	
}

//PS:由于部分51单片机没有malloc函数库，固采用数组方案平替。

//=================51单片机的ringbuffer方案====================

#include <stdio.h>
#include <stdlib.h>

typedef struct TAG_RING_BUFFER
{
    int wrPos;
    int rdPos;
    int maxCount;
	int remainCnt;
    char *buffer;
	
} TagRingBuffer;

void ringBuffer_init(TagRingBuffer *rb, int size, char *new_buffer)
{
	// Note: (size-1) is full!!
	if (rb == NULL)
	{
		return;
	}
	rb->buffer = new_buffer;
	if (rb->buffer == NULL)
	{
		return;
	}
	rb->maxCount = size;
	rb->wrPos = 0;
	rb->rdPos = 0;
	rb->remainCnt = 0;
	return;
}

void ringBuffer_free(TagRingBuffer *rb)
{
	if (rb)
	{
		if (rb->buffer)
		{
			free(rb->buffer);
		}
		free(rb);
	}
}

int is_ringBuffer_full(TagRingBuffer *rb)
{
	// Note:(MAXCOUNT-1) is full!!
	if (((rb->wrPos) + 1) % (rb->maxCount) == rb->rdPos)
		return 1;

	return 0;
}

int is_ringBuffer_empty(TagRingBuffer *rb)
{
	if ((rb->wrPos) == rb->rdPos)
		return 1;
	return 0;
}

int ringBuffer_pop(TagRingBuffer *rb, char *ch)
{ // read
	if (is_ringBuffer_empty(rb))
	{
		return 0;
	}
	*ch = rb->buffer[rb->rdPos];
	rb->rdPos = (rb->rdPos + 1) % rb->maxCount;
	rb->remainCnt--;
	return 1;
}

int ringBuffer_push(TagRingBuffer *rb, char ch)
{ // write
	if (is_ringBuffer_full(rb))
	{
		return 0;
	}
	rb->buffer[rb->wrPos] = ch;
	rb->wrPos = (rb->wrPos + 1) % (rb->maxCount);
	rb->remainCnt++;
	return 1;
}

int ringBuffer_getRemainCnt(TagRingBuffer *rb)
{
	return rb->remainCnt;
}

void dump_hex(char *data, int len, char *info)
{
	printf("%s(%d) ", info, len);
	for (size_t i = 0; i < len; i++)
	{
		printf("%02x ", (unsigned char)data[i]);
	}
	printf("\n");
}

// RingBuffer 测试[单元素],适用于8051等单片机
void main()
{

	TagRingBuffer rb1;
	TagRingBuffer rb2;
	char i, ch;
	int retn = 1;
	int remain = 0;
	static char new_buffer1[5] = {0};
    static char new_buffer2[8] = {0};

	ringBuffer_init(&rb1, sizeof(new_buffer1), new_buffer1);
	ringBuffer_init(&rb2, sizeof(new_buffer2), new_buffer2);

	
	ringBuffer_push(&rb1, 1);
	ringBuffer_push(&rb1, 3);
	ringBuffer_push(&rb1, 5);
	ringBuffer_push(&rb1, 7); // effect data
	ringBuffer_push(&rb1, 9); // buffer is full
	ringBuffer_push(&rb1, 11);
	ringBuffer_push(&rb1, 13);

	ringBuffer_push(&rb2, 101);
	ringBuffer_push(&rb2, 103);
	ringBuffer_push(&rb2, 105);
	ringBuffer_push(&rb2, 107);  
	ringBuffer_push(&rb2, 109);  
	ringBuffer_push(&rb2, 101);	
    ringBuffer_push(&rb2, 103);	



	printf("==========BUILD:%s %s=========\n", __TIME__, __DATE__);
	for (i = 0; i < 10; i++)
	{ // 测试超出ringbuffer范围的数据
		ch = 0;
		remain = ringBuffer_getRemainCnt(&rb1);
		retn = ringBuffer_pop(&rb1, &ch);
		printf("[%d] rb1_out_data=(%d),remain=%d,ret=%d.\n", i, ch, remain, retn);
	}
	printf("=============================================\n");	
	for (i = 0; i < 10; i++)
	{ // 测试超出ringbuffer范围的数据
		ch = 0;
		remain = ringBuffer_getRemainCnt(&rb2);
		retn = ringBuffer_pop(&rb2, &ch);
		printf("[%d] rb2_out_data=(%d),remain=%d,ret=%d.\n", i, ch, remain, retn);
	}	
}

wabil
关注
专栏目录
环形缓冲器（ring buffer，圆形队列）总结-java版
许诗宇的博客
05-15 6636
目录 为什么要有环形缓冲器 简介 区分缓冲区是否为满的策略 总是保持一个存储单元为空 使用数据计数 镜像指示位 java实现 为什么要有环形缓冲器 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释放掉，再处理下一个。那么，已经处理的数据的内存就会被浪费掉。因为后来的数据只能往后排队，如果要将剩余的数据都往前移动一...
linux 串口环形缓冲区,环形缓冲区的实现原理（ring buffer）（小寿转载 ）
weixin_39796140的博客
05-09 717
在通信程序中，经常使用环形缓冲区作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。1、环形缓冲区的实现原理环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅...
环形缓冲区的使用
chunchun2021的博客
03-28 1399
环形缓冲区是一个先进先出（FIFO）的闭环的存储空间。相当于就是一个固定大小的数组，和两个指针，读指针和写指针。环形 缓冲区的”环形“特性意味着当任一指针到达数组的末端的时候，会自动回绕到数据开始的位置。
ring_buffer
10-09
webrtc的 ring_buffer 环形队列 C/C++ 实现 环形缓冲区
基于STM32瑞士军刀--【FreeRTOS开发】学习笔记（五）|| 队列 | 队列实验（打砖块游戏）
最新发布
qq_44578108的博客
08-01 686
中断写队列仅适用于较简单的任务，复杂任务在任务中写队列。最终实现红外遥控器和旋转编码器都能控制挡球板移动。
环形缓冲区
蜜汁程序员的博客
10-20 2万+
https://blog.csdn.net/p23onzq/article/details/80750745 .https://blog.csdn.net/blade2001/article/details/7094232/ 正在造轮子，同时不停地在找哪里有这个轮子 原因： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的，那么处理完后呢，就会把数据释...
环形队列实现原理
热门推荐
Kfree博客园
07-09 4万+
环形队列是在实际编程极为有用的数据结构,它有如下特点。   它是一个首尾相连的FIFO的数据结构，采用数组的线性空间,数据组织简单。能很快知道队列是否满为空。能以很快速度的来存取数据。   因为有简单高效的原因，甚至在硬件都实现了环形队列.    环形队列广泛
环形缓冲区（ringbuffer）
loveliu928的博客
03-29 1万+
环形缓冲区（ringbuffer） 环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在串口处理中，串口中断接收数据直接往环形缓冲区丢数据，而应用可以从环形缓冲区取数据进行处理，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。 环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样 在此之前，我们来回顾一下队列的基本概念
【转】环形队列理论（C语言）
weixin_30907523的博客
08-04 240
原文链接：http://blog.sina.com.cn/s/blog_8b200d440100xsug.html 环形队列是在实际编程极为有用的数据结构,它有如下特点。 它是一个首尾相连的FIFO的数据结构，采用数组的线性空间,数据组织简单。能很快知道队列是否满为空。能以很快速度的来存取数据。 因为有简单高效的原因，甚至在硬件都实现了环形队列. 环形队列广泛用于网...
在C语言中用环形缓冲区（ring buffer）实现队列（queue）的各项操作。
04-10
可以使用环形缓冲区（ring buffer）实现队列（queue）的各项操作，包括入队（enqueue）、出队（dequeue）、判断队列是否为空（isEmpty）和判断队列是否已满（isFull）。在环形缓冲区中，如果写入数据的指针等于缓冲...
ring_buffer:基于Erlang的环形或环形缓冲区的实现
03-05
RingBuffer是环形或环形缓冲区数据结构的实现，内部基于Erlang的：queue。 RingBuffer具有:max_size ，它是在创建时通过new/1指定的。 在一个:size小于其:max_size的RingBuffer上调用put/2将会： 将项目添加到...
环形缓冲区实现类(RingBuffer)
09-01
环形缓冲区实现类(RingBuffer)
理解Python中的RingBuffer环形缓冲区
漫步量化
05-31 3307
ringbuffer Refered from Wikipedia, a ring buffer(环形缓冲区 or circular buffer, circular queue, cyclic buffer) is a data strcture that uses a single, fixed-size buffer as if it were connected end-to-end. This structure lends itself easily to buffering data s..
Ring Buffers （环形消息缓冲区)
wangyx1234的博客
07-30 5611
Ring Buffers 基本结构 即环形缓冲区：添加环形缓冲区是为了提供一种可以接受任意长度条目的缓冲区形式。 （内存管理）是一种数据结构用于表示一个固定尺寸、头尾相连的缓冲区，适合缓存数据流。内部除维护一个环形缓冲区外，还有两个二值信号量，用于读写保护： 1.发送保护信号量：二值信号量，通知被阻塞发送的任务有更多可用空间或阻塞已经超时。 2.接收保护信号量，二值信号量，通知被阻塞接收的任务指示新的数据/项已写入环形缓冲区或者阻塞超时。 为什么需要Ring Buffers...
队列(queue)环形缓冲区(ring buffer)，环形队列(ring queue)
dianqicyuyan的博客
02-11 4012
什么是环形缓冲区？想要学会环形队列，你是不是得先学习一下队列？？？（如何在程序中实现队列？） 如何在代码中实现环形缓冲区？ 环形缓冲区适用于甚麽样的场合？ 环形缓存区： 环形缓冲器（ringr buffer），也称作圆形队列（circular queue），循环缓冲区（cyclic buffer），圆形缓冲区（circula buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 背景： 当有大量数据的时候，我们不能存储所有的数据，那么计算机处理数据的时候，只能先处理先来的
环形缓冲区的设计及其在生产者消费者模式下的使用（并发有锁环形队列）
weixin_30347335的博客
01-19 463
1、环形缓冲区 缓冲区的好处，就是空间换时间和协调快慢线程。缓冲区可以用很多设计法，这里说一下环形缓冲区的几种设计方案，可以看成是几种环形缓冲区的模式。设计环形缓冲区涉及到几个点，一是超出缓冲区大小的的索引如何处理，二是如何表示缓冲区满和缓冲区空，三是如何入队、出队，四是缓冲区中数据长度如何计算。 ps.规定以下所有方案，在缓冲区满时不可再写入数据，缓冲区空时不能读数据 1.1、常规数组环形...
网络字节流数据解析组件的设计与实现--Circular Buffer(Ring Buffer)
weixin_30664051的博客
08-09 342
1. 应用场景 网络编程中有这样一种场景：需要应用程序代码一边从TCP/IP协议栈接收数据（reading data from socket），一边解析接收的数据。具体场景例如：用户点击Youtube或优酷网站上的视频内容，这时用户PC上的播放软件就是一边接收数据一边对数据进行解码并播放的。这样的场景的存在如下约束：1. 必须边接收数据，边对数据进行解析，不能等待到数据全部接收完整后...
[缓存] RingBuff 环形队列、环形缓冲区及有锁无锁实现
小田的专栏
02-20 1769
由于自旋锁不需要进行线程切换，所以它完全在用户态下实现，加锁开销低，但是由于其采用忙等待的策略，对于短期加锁来说没问题，但是长期锁定的时候就会导致CPU资源的大量消耗。如果读取数据的速度跟不上写入数据的速度，旧的数据将被新写入的数据覆盖。所以当互斥锁加锁失败的时候，就伴随着两次上下文切换的开销，而如果我们锁定的时间较短，可能上下文切换的时间会比锁定的时间还要长。由于自旋锁和互斥锁的失败策略不同，自旋锁采用忙等待的策略，而互斥锁采用线程切换的策略，由于策略不同，它们的应用场景也不同。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值