环形缓冲区的设计与实现

最新推荐文章于 2021-05-23 18:08:40 发布
最新推荐文章于 2021-05-23 18:08:40 发布
阅读量1k 收藏 6
点赞数 2
分类专栏： unix编程杂谈

转载至：http://blog.csdn.net/wanxiao009/article/details/5519514

环形缓冲区是嵌入式系统中十分重要的一种数据结构，比如在一个视频处理的机制中，环形缓冲区就可以理解为数据码流的通道，每一个通道都对应着一个环形缓冲区，这样数据在读取和写入的时候都可以在这个缓冲区里循环进行，程序员可以根据自己需要的数据大小来决定自己使用的缓冲区大小。

    环形缓冲区，顾名思义这个缓冲区是环形的，那么何谓环形这个意思也很好理解，就是用一个指针去访问该缓冲区的最后一个内存位置的的后一位置时回到环形缓冲区的起点。类似一个环一样。这样形容就很好理解了，当然有办法实现了。我在这里采用了2种方式实现了环形缓冲区，一个是用数组的方法，一个是用链表的方法。

    数组是一块连续的内存，所以顺序访问时只要根据下标的增加而增加，但是最后一个元素之后需要回到起始位置，这就需要我们对这个地方进行特殊处理。只要最后一个地址访问结束能顺利回到起始地址，这个缓冲区就可以实现。代码如下：


[cpp] view plain copy
print?

    /* File name: ringbuf.c 
     * Author   : wanxiao 
     * Function :Implement a circular buffer,  
                 you can read and write data in the buffer zone. 
     */  
      
    #include <stdio.h>     
        
    #define MAXSIZE 8     
        
    int ringbuf[MAXSIZE];     
    int readldx=0;  
    int writeldx=0;  
      
    int next_data_handle(int addr)     
    {     
        return (addr+1) == MAXSIZE ? 0:(addr+1) ;     
    }     
        
    int write_data(int data)  
    {  
        int i;  
        *(ringbuf+writeldx) = data;  
        writeldx = next_data_handle(writeldx);  
        for(i=0;i<MAXSIZE;i++)  
        {  
            printf("%4d",*(ringbuf+i));  
            if(MAXSIZE-1 == i)  
                printf("/n");  
        }  
    }  
      
    int read_data()  
    {  
        printf("read data is : %d/n",*(ringbuf+readldx));  
        readldx = next_data_handle(readldx);  
    }  
        
    int main(int argc , char **argv)     
    {     
        int data;     
        char cmd;  
      
        do{     
            printf("select:/nw/t--write/nr/t--read/nq/t--quit/n");     
            scanf("%s",&cmd);     
        
            switch(cmd)     
            {     
                case 'w' :     
                    printf("please input data:");     
                    scanf("%d",&data);     
                    write_data(data);     
                    break;     
                case 'r' :     
                    data = read_data();     
                    break;     
                case 'q' :     
                    printf("quit/n");     
                    break;     
                default :     
                    printf("Command  error/n");     
            }     
        }while(cmd != 'q');     
        return 0;     
    }

链表实现，实际上就是一个单向循环链表。这个方法的优点是不需要最后一个元素进行特殊处理，但是实现起来比数组稍微麻烦一点，单思路还是很清晰简单的。代码如下：

    #include <stdio.h>  
    #include <stdlib.h>  
      
      
    typedef struct signal_loop_chain  
    {  
        int data;  
        struct signal_loop_chain *next;  
    }NODE;  
      
    NODE *Create_loop_chain(int n)  
    {  
        int i;  
        NODE *head , *previous , *current ;  
        previous = (NODE *)malloc(sizeof(NODE));  
        if(previous == NULL)  
            exit(1);  
      
        previous->data =0;  
        previous->next = NULL;  
        head = previous ;  
      
        for(i=0 ; i<n ; i++)  
        {  
            current = (NODE*)malloc(sizeof(NODE));  
            if(current == NULL)  
                exit(1);  
      
    //      scanf("%d",¤t->data);  
            current->next = head;  
            previous->next = current;  
            previous = current ;  
        }  
        return head ;  
    }  
      
    int Show(NODE *head)  
    {  
        NODE *current;  
        current = head->next ;  
        printf("List:/n");  
        while(current != head)  
        {  
            printf("%4d",current->data);  
            current = current->next;  
        }  
        printf("/n");  
    }  
      
    int read_buf(NODE *head)  
    {  
        NODE *current;  
        current = head->next;  
        while(1)  
        {  
            printf("read number is %d/n",current->data);  
            current = current->next;  
            sleep(1);  
        }  
      
    }  
      
    int write_buf(NODE *head)  
    {  
        NODE *current;  
        int i = 0;  
        current = head->next;  
        while(1)  
        {  
            current->data = i++;  
            printf("write number is %d/n",current->data);  
            current = current->next;  
            sleep(1);  
        }  
    }  
      
    int main(int argc , char **argv)  
    {  
        int num;  
        char cmd;  
        NODE *head;  
        printf("please input node_num /n");  
        scanf("%d",&num);  
        head = Create_loop_chain(num);  
        printf("The ringbuf was found/n");  
        Show(head);  
      
        while(1){  
            printf("please select r or w/n");  
            scanf("%c",&cmd);  
      
            if(cmd == 'r'){  
                read_buf(head);  
                Show(head);  
            }  
              
            if(cmd == 'w'){  
                write_buf(head);  
                Show(head);  
            }  
              
        }  
        return 0;  
    }

以上都是针对单进程而言。对于系统，尤其是嵌入式Linux系统中，缓冲区的保护机制就变得尤为重要了，因为我们的数据时不停的在读写，内存不停的变化，如果牵扯到多任务（多进程，多线程），我们就需要加锁对其进行保护措施。这里我在链表的实现下加了信号量加以保护。以上都是针对单进程而言。对于系统，尤其是嵌入式Linux系统中，缓冲区的保护机制就变得尤为重要了，因为我们的数据时不停的在读写，内存不停的变化，如果牵扯到多任务（多进程，多线程），我们就需要加锁对其进行保护措施。这里我在链表的实现下加了信号量加以保护。 


    #include <stdio.h>  
    #include <stdlib.h>  
    #include <pthread.h>  
    #include <semaphore.h>  
      
    sem_t mutex;  
      
    typedef struct signal_loop_chain  
    {  
        int data;  
        struct signal_loop_chain *next;  
    }NODE;  
      
    NODE *Create_loop_chain(int n)  
    {  
        int i;  
        NODE *head , *previous , *current ;  
        previous = (NODE *)malloc(sizeof(NODE));  
        if(previous == NULL)  
            exit(1);  
      
        previous->data =0;  
        previous->next = NULL;  
        head = previous ;  
      
        for(i=0 ; i<n ; i++)  
        {  
            current = (NODE*)malloc(sizeof(NODE));  
            if(current == NULL)  
                exit(1);  
      
            current->next = head;  
            previous->next = current;  
            previous = current ;  
        }  
        return head ;  
    }  
      
    int Show(NODE *head)  
    {  
        NODE *current;  
        current = head->next ;  
        printf("List:/n");  
        while(current != head)  
        {  
            printf("%4d",current->data);  
            current = current->next;  
        }  
        printf("/n");  
    }  
      
    int read_buf(NODE *head)  
    {  
        NODE *current;  
        current = head->next;  
        while(1)  
        {  
            sem_wait(&mutex);  
            printf("read number is %d/n",current->data);  
            current = current->next;  
            sem_post(&mutex);  
            sleep(2);  
        }  
      
    }  
      
    int write_buf(NODE *head)  
    {  
        NODE *current;  
        int i = 0;  
        current = head->next;  
        while(1)  
        {  
            sem_wait(&mutex);  
            current->data = i++;  
            printf("write number is %d/n",current->data);  
            current = current->next;  
            sem_post(&mutex);  
            sleep(1);  
        }  
    }  
      
    int main(int argc , char **argv)  
    {  
        int num,ret;  
        char cmd;  
        NODE *head;  
        pthread_t id1,id2;  
      
        ret = sem_init(&mutex ,0,1);  
        if(ret != 0){  
            perror("sem_init error");  
        }  
        printf("please input node_num /n");  
        scanf("%d",&num);  
        head = Create_loop_chain(num);  
        printf("The ringbuf was found/n");  
        Show(head);  
      
        ret = pthread_create(&id1,NULL,(void *)write_buf,head);  
        ret = pthread_create(&id2,NULL,(void *)read_buf,head);  
      
        pthread_join(id1,NULL);  
        pthread_join(id2,NULL);  
          
      
        return 0;  
    }




葫芦娃二娃
关注
专栏目录
c语言数组实现环形缓冲区,[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
weixin_35775446的博客
05-21 849
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理，只要保...
高速通信下环形缓冲区设计及实现
09-22
1.高速通信下，环形缓冲区设计及实现；可直接使用演示。 2.包括：服务端和客户端。说明：SOCKET通信非常简略，只为环形缓冲区测试使用，也适合初学都学习。 其他：里面包含SOCKET通信客户端/服务器演示，还包括了环形缓冲区现成的代码。
数组实现环形缓冲区
weixin_43566833的博客
05-23 201
#include “irda_raw.h” #define NEXT_PLACE(i) ((i+1)&0x3FF) static irda_raw_event g_events[1024]; static int g_r = 0; static int g_w = 0; static int is_ir_event_buf_empty(void) { return g_r == g_w; } static int is_ir_event_buf_full(void) { return NEXT_PL
环形缓冲区设计
logens的专栏
06-13 255
流的处理很多地方都用到了环形缓冲区，其实就是开辟的一段内存区域，重复使用，有流经过时，就写入 里边，当前的写入点，可以是缓冲区中的任意一点，当然，此时读入点和写入点重合的话，表明此时的 缓冲区已被占满，流的尺寸太大。 class CCycleBuffer { public: bool isFull(); bool isEmpty(); void empty(); int getLeng...
环形逻辑缓存的一种C++实现
paradox_1_0的博客
05-22 263
1.简单示意图如下 2.实现代码 #ifndef CACHE_H_ #define CACHE_H_ #include<stdio.h> #include<stdlib.h> #include<string.h> #define CACHESIZE (/*8 * 10*/24)//1M class C...
STM32进阶之串口环形缓冲区实现
10-01
完成环形缓冲区的设计后，可以通过发送一系列连续的数据来验证其正确性。如果能够成功接收到所有数据而无任何丢失，则证明环形缓冲区实现成功。 #### 七、总结 通过引入环形缓冲区机制，我们能够有效提升串口通信...
基于STM32FxUART数据传输环形缓冲区实现
05-08
本项目重点在于基于STM32F系列（具体为STM32Fx）的UART（通用异步收发传输器）数据传输，通过环形缓冲区的实现来优化通信效率。下面将详细解释这一技术及其应用。 首先，**UART** 是微控制器与外界进行串行通信的...
C语言实现循环缓冲区（环形缓冲区）
最新发布
01-11
循环缓冲区，也称为环形缓冲区，是计算机科学中一种高效的数据结构，常用于处理实时数据流。在C语言中实现循环缓冲区涉及到内存管理、数据读写以及线程安全等多个方面。以下是对这个主题的详细阐述： 一、概念理解 ...
简单实用的环形缓冲器
tifentan的专栏
08-25 616
简单实用的环形缓冲器近来处理音频rawdata时需要一个FIFO的内存缓冲，自己写了一个基于环形结构的缓冲器。 可处理任意大小输入，输出 数据不够时可强制获取剩余数据 代码简单明了 bug可能有，暂时没发现。/* * CREATE: tifentan * DATE: 2017/8/23 * MODIFY: 2017/8/23 * NOTE: * * */#ifndef __CIRCLEBUFFER_
C语言： 环形缓存区
Linux
10-31 913
typedef unsigned char BYTE; typedef unsigned int DWORD; typedef unsigned short WORD; #define len_ring_buf 1024 #define portnum 2048 typedef struct { BYTE *head; //头 BYTE *tail; //尾 BYTE *Doga...
缓冲的设计
xiaowenmu1的博客
05-17 310
本人实现了一个buffer，该buffer相当于一个环形缓冲区，添加数据时内部数据不需要挪动位置。该缓冲并没有实现缓冲的收缩功能以及对字节大小端的转换，如果需要稍微改进下就可以了。有兴趣的可以在GitHub上下载:https://github.com/xiaowenmu/buffer ...
算法 第四版 1.3.39 环形缓冲区
BRCOCOLI的博客
09-04 819
public class RingBuffer { /** * @param args */ private Item[] a; private int first=0, last=0; public RingBuffer(int N){ a = (Item[]) new Object[N]; } public boolean isEmpty(){ return firs
环形缓冲区的设计及其在生产者消费者模式下的使用（并发有锁环形队列）
weixin_30347335的博客
01-19 468
1、环形缓冲区 缓冲区的好处，就是空间换时间和协调快慢线程。缓冲区可以用很多设计法，这里说一下环形缓冲区的几种设计方案，可以看成是几种环形缓冲区的模式。设计环形缓冲区涉及到几个点，一是超出缓冲区大小的的索引如何处理，二是如何表示缓冲区满和缓冲区空，三是如何入队、出队，四是缓冲区中数据长度如何计算。 ps.规定以下所有方案，在缓冲区满时不可再写入数据，缓冲区空时不能读数据 1.1、常规数组环形...
java 环形数组缓冲区
Sun_Ru的博客
09-04 3196
package Server; //环形数组缓冲区 缓冲区所能存放的数据为缓冲区大小的个数 减去1 为实际能存储的大小 public class Area_Buffer { private byte[] buf=null; private int start; private int end; public Area_Buffer(int s){//构造函数定义缓冲区的大小 buf =
Netty之缓冲区Bytebuf+管道模型(五)
贾红平
06-25 636
1 原理介绍
缓冲区设计--环形队列
热门推荐
海涛的专栏
08-07 2万+
在程序的两个模块间进行通讯的时候，缓冲区成为一个经常使用的机制。 如上图，写入模块将信息写入缓冲区中，读出模块将信息读出缓冲区。这样使得：将程序清晰地划分模块，建立良好的模块化架构，使得写入和读出成为高聚合，低耦合的模块。对于写入和读出的处理可能产生的快慢不均匀的情况进行平衡，使得整个处理的速度趋于平滑的均匀状态
Qt：通过预解释和预读取，大幅度提升图片加载速度
Jason’s home
03-28 8856
在我以往的开发中，尤其是嵌入式，图片的加载一直是一个头疼的问题。图片大了，加载就很慢，在嵌入式上，一个1280*1080的图片，加载可能要好几百毫秒。也就是说加载一个背景，就可能要花去几百毫秒，还不包括其他各种图片。 在用尽各种奇妙的方法后，今天终于找到一个根治的方法。赶紧来和大家分享下。 首先，我们要知道一个图片的加载，时间到底消耗在哪。 一般来说，一个图片加载，可以分为两步，第一步是从硬...
C++单线程环形缓冲区实现与并发优化
本文主要探讨了一个C++实现的环形缓冲区，特别是在单线程环境下读写操作的分析与高效实现，以及在并发情况下如何避免使用信号量来管理共享资源，从而提升程序性能和一致性。 首先，环形缓冲区是一种常见的数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值