环形缓冲区【转】-CSDN博客

本文转载自：http://blog.csdn.net/u013904227/article/details/51168398

1、什么是环形缓冲区

环形缓冲区，顾名思义就是一个环状的存储数据的区域，其空间使用数组进行构造（链表也可以）。环形缓冲区特点是读和写可以是分开的，写入数据之后可以先不去读取，等到需要读取的时候再去读取，并且数据一经读取之后下次就不能再去读取（当然也可以实现重复读取的效果，不过大多用作一次性读取），等于说是一次性的读取。
假设一个长度为256字节的数组，构建出一个环形缓冲区，当写操作进行到数组的第256项之后，再一次写入就会回到第0个进行写入；同样读操作是读取到数组的第256项时，再一次进行读取就会回到数组的第一项。是谓环形缓冲

2、环形缓冲区的作用

用作需要大量写入并且大量一次性读写的数据缓存区

比如视频的写入读取：在视频播放的时候需要不断的进行写入读取操作，而且数据一经读出就会显示出来，下次就不再需要已经读出的数据了。使用环形缓冲区可以满足这个要求，并且实现读写分别进行，而且节省了空间。

用作进程间通信，减少加锁开销

由于环形缓冲区的读写分开特性，当两个线程进行通信的时候，可以采用环形缓冲区进行交流，一个进程读取，一个进程写入，由于读写的位置不同，并不需要加锁进行并发控制，也就减少了锁的时间开销

3、程序编写测试（基于嵌入式linux的kmesg方式建立）

/* 使用printk函数打印调试信息，调试信息写到proc里面，形成一个环形缓冲区 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h> #include <linux/proc_fs.h> #include <asm/uaccess.h> /* proc的文件结构体 */ struct proc_dir_entry *entry; #define MAX_COUNT 1024 //缓冲区长度 static char proc_buffer[MAX_COUNT]; //缓冲区数组 static int empty_flag = 0; //是否为空，0表示为空 static int last_r_pos = 0; static int mymsg_r = 0; //读位置 static int mymsg_w = 0; //写位置 /* 判断是否为空 */ static int is_empty_mymsg(void) { if(((mymsg_w % MAX_COUNT) == (mymsg_r % MAX_COUNT)) && (empty_flag == 0)){ return 1; //Is empty } return 0; //Is not empty } /* 判断是否为满 */ static int is_full_mymsg(void) { if(((mymsg_w % MAX_COUNT) == (mymsg_r % MAX_COUNT)) && (empty_flag != 0)){ return 1; //Is full } return 0; //Is not full } /* 读取一个字节 */ static int read_onebyte_mymsg(char *buf_p) { if(is_empty_mymsg()){ return 0; //empty buffer can't read } *buf_p = proc_buffer[mymsg_r % MAX_COUNT]; mymsg_r = (mymsg_r + 1) % MAX_COUNT; empty_flag --; //每读取一个字节空标志减去1 return 1; } /* 写入一个字节 */ static void write_onebyte_mymsg(char byte) { proc_buffer[mymsg_w % MAX_COUNT] = byte; if(is_full_mymsg()){ mymsg_r = (mymsg_r + 1) % MAX_COUNT; empty_flag --; } mymsg_w = (mymsg_w + 1) % MAX_COUNT; empty_flag ++; //每写入一个字节，空标志加一 } /* 执行cat命令的时候会调用到，直到返回为空的时候cat才会返回 */ static ssize_t printk_drv_read(struct file *f_name, char __user *buf, size_t cont, loff_t *lof) { char byte_to_user; cont = read_onebyte_mymsg(&byte_to_user); __put_user(byte_to_user, buf); return cont; } /* 自建打印函数，另带有往环形缓冲区里面写入数据的功能 */ int myprintk(const char *fmt, ...) { va_list args; int r; va_start(args, fmt); r = vprintk(fmt, args); va_end(args); while(r --){ write_onebyte_mymsg(*fmt++); } return r; } EXPORT_SYMBOL(myprintk); const struct file_operations proc_mymsg_operations = { .owner = THIS_MODULE, .read = printk_drv_read, }; static int printk_drv_init(void) { int i = 0; /* 打印测试 */ for(i = 0; i < MAX_COUNT; i++){ myprintk("F"); } /* 边界测试 */ for(i = 0; i < 5; i++){ myprintk("Y"); } // myprintk("Function printk_drv_init is running\n"); entry = create_proc_entry("mymsg", S_IRUSR, &proc_root); if (entry) entry->proc_fops = &proc_mymsg_operations; // myprintk("Function printk_drv_init finished\n"); return 0; } static void printk_drv_exit(void) { remove_proc_entry("mymsg", &proc_root); } module_init(printk_drv_init); module_exit(printk_drv_exit); MODULE_LICENSE("GPL");

4、测试结果

insmod myprintk.ko FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFYYYYY cat /proc/mymsg FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFYYYYY //开始的5个F被清除掉了 cat /proc/mymsg 空

5、判断环形缓冲区的空或者满

设置额外的标志位

例如上面例子中的empty_flag，写的时候加上1，读的时候减去1，当满足读等于写并且empty_flag为0，则说明缓冲区空了。如果满足读等于写并且empty_flag不为0，说明缓冲区满了。

环形缓冲区始终空出一个值

例如:

/* 判断是否为空 */
static int is_empty_mymsg(void)
{
    //if(((mymsg_w % MAX_COUNT) == (mymsg_r % MAX_COUNT)) && (empty_flag == 0)){ if(((mymsg_w % MAX_COUNT) == (mymsg_r % MAX_COUNT))){ return 1; //Is empty } return 0; //Is not empty } /* 判断是否为满 */ static int is_full_mymsg(void) { //if(((mymsg_w % MAX_COUNT) == (mymsg_r % MAX_COUNT)) && (empty_flag != 0)){ if((((mymsg_w + 1) % MAX_COUNT) == (mymsg_r % MAX_COUNT))){ return 1; //Is full } return 0; //Is not full }