java环形buff_环形缓冲区.ringbuff(C#和java)

最新推荐文章于 2024-02-20 03:33:47 发布
最新推荐文章于 2024-02-20 03:33:47 发布
阅读量1.4k 收藏 1
点赞数
文章标签： java环形buff
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36264801/article/details/114890435
版权

环形缓冲，

本质就是队列fifo，先进先出的特殊版本，环形队列，是用空间得到了顺序存储的快索引的优点，又避免了删除，移动数据的缺点。并且还享受了单生产/单消费，2线程的无锁线程优势。十分完美。

1.面对频率超级频繁的读写，环形缓冲修改为固定大小的队列，不添加操作，并且使用后，也不删除和移动。坏处是，必须预设内存空间。所以适合超级频繁的读写，反正基本是一直占用。

2.因为要实现环形，所以一般有2个哨兵，如果是2个线程，一个读一个写。环形缓冲，还可以避免线程锁。非常棒。即所谓单生产/单消费模式的共享队列是不需要加锁同步的

3.固定大小。所以数组 xxx[]，非常适合改造为环形缓冲。char[] 改为字符群缓冲 . object[] 改为对象群缓冲

花了点时间，写了下。测试用例测试了下。没发现问题。

感觉缓存区必须根据实际情况写特例。

这里缓存区，适合 读必须大于写。

特点

1.写满会 自动跳过。 所以需要根据情况，定制缓存区大小，或者改写为自动扩大缓存区。

2.读，如果无数据会直接出去，无阻塞.

3. 如果可行的话，可以使用多个ringbuff，来代替多线程的方案

需改进：

定义一个最大缓存区大小。让缓存区可以自动扩大，到最大就不扩大了。

179274984_1_20191231042251191.gif

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace BaseLib

{

///

///环形缓冲区. c# byte== c++ unsign char . c# char==c ++ char.///环形缓冲结构，不考虑在读或写某端有多线程的情况，因为环形缓冲结构就是为了不锁下的性能，适合读写同一个线程，或者读写各一个线程。///

public class RingBuff

{

private byte[] ringBuff;

private int nextWritePos;

private int nextReadPos;

private int buffSize;

private int capcity;

public RingBuff(int _size)

{

capcity=buffSize = _size;

ringBuff = new byte[buffSize];

nextWritePos = 0;

nextReadPos = 0;

}

///

///写入缓存///

/// 要写入的数据

/// 是否写入

public bool WriteBuff(byte[] _buff)

{

bool ret = false;

int bsize = _buff.Length;

if (capcity < bsize)

{

ret = false;

}

else

{

int rightLeft = buffSize - nextWritePos;

//need reture to head

if (bsize > rightLeft)

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, rightLeft);

Array.Copy(_buff, rightLeft, ringBuff, 0, bsize - rightLeft);

nextWritePos = bsize - rightLeft;

}

else if (bsize == rightLeft)

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

nextWritePos = 0;

}

else

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

nextWritePos += bsize;

}

capcity = capcity - bsize;

ret = true;

}

return ret;

}

///

///写入缓存，指定读取源的长度.///

///

///

///

public bool WriteBuff(byte[] _buff, int len)

{

int bsize = len;//_buff.Length;

bsize = len > _buff.Length ? _buff.Length : bsize;

if (capcity < bsize)

{

return false;

}

else

{

int rightLeft = buffSize - nextWritePos;

//need reture to head

if (bsize > rightLeft)

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, rightLeft);

Array.Copy(_buff, rightLeft, ringBuff, 0, bsize - rightLeft);

nextWritePos = bsize - rightLeft;

}

else if (bsize == rightLeft)

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

nextWritePos = 0;

}

else

{

Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

nextWritePos += bsize;

}

capcity -= bsize;

return true;

}

}

///

///读缓存,是否预读，而不移动读哨兵.///

/// 读入的临时缓存

/// 实际读出的数据长度

public int ReadBuff(ref byte[] readbuff, bool MovePosition = true)

{

int len = readbuff.Length;

int enableread = buffSize - capcity;

Array.Clear(readbuff, 0, len);

if (len <= 0 || enableread <= 0)

{

return 0;

}

else

{

int realRead = enableread >= len ? len : enableread;

int rightLeft = buffSize - nextReadPos;

if (realRead > rightLeft)

{

Array.Copy(ringBuff, nextReadPos, readbuff, 0, rightLeft);

Array.Copy(ringBuff, 0, readbuff, rightLeft, realRead - rightLeft);

if (MovePosition)

{

nextReadPos = realRead - rightLeft;

}

}

else if (realRead == rightLeft)

{

Array.Copy(ringBuff, nextReadPos, readbuff, 0, realRead);

if (MovePosition)

{

nextReadPos = 0;

}

}

else

{

Array.Copy(ringBuff, nextReadPos, readbuff, 0, realRead);

if (MovePosition)

{

nextReadPos += realRead;

}

}

capcity += realRead;

return realRead;

}

}

public string GetBuffInfo()

{

StringBuilder sb = new StringBuilder();

sb.Append(System.Threading.Thread.CurrentThread.Name + ":writePositon:" + nextWritePos.ToString());

sb.Append(". readPosition:" + nextReadPos.ToString());

sb.Append(". size:");

sb.Append(buffSize);

sb.Append(".enable read:" + (buffSize-capcity).ToString() + ".enable write:" + capcity.ToString());

sb.Append(System.Environment.NewLine);

sb.Append("1-10 byte:");

for (int i = 0; i < 10; i++)

{

sb.Append(ringBuff[i].ToString("x")+"|");

}

return sb.ToString();

}

private RingBuff()

{ }

}

}

179274984_1_20191231042251191.gif

测试例子

179274984_1_20191231042251191.gif

static void TestRingBuff()

{

int buffSize = 10;

BaseLib.RingBuff rb = new BaseLib.RingBuff(buffSize);

Console.WriteLine(rb.GetBuffInfo());

测试读满，和写满。

//for (int i = 0; i < 12; i++)//{//rb.WriteBuff(new byte[] { (byte)testChar });//testChar++;//Console.WriteLine(rb.GetBuffInfo());//}//byte[] tempReadBuff = new byte[1];//for (int i = 0; i < 15; i++)//{//rb.ReadBuff(ref tempReadBuff);//Console.WriteLine(tempReadBuff[0].ToString("x"));//Console.WriteLine(rb.GetBuffInfo());//}

//字符是依次 + 1写入缓存。所以测试首先关注各种情况下，是否读出的数据是联系的。就可大概确定数据是没有丢失和跳跃的。测试读慢，写快.

//while (true)//{//bool ret = rb.WriteBuff(new byte[] { (byte)testChar, (byte)++testChar, (byte)++testChar });//if (ret == false)//{//--testChar;//--testChar;//--testChar;//}//Console.WriteLine(rb.GetBuffInfo());//byte[] tempReadBuff = new byte[2];//rb.ReadBuff(ref tempReadBuff);//Console.WriteLine(tempReadBuff[0].ToString("x") + "." + tempReadBuff[1].ToString("x"));//++testChar;//System.Threading.Thread.Sleep(1000);//}

测试读快，慢写

//while (true)//{//bool ret = rb.WriteBuff(new byte[] { (byte)testChar, (byte)++testChar });//if (ret == false)//{//--testChar;//--testChar;//}//Console.WriteLine(rb.GetBuffInfo());//byte[] tempReadBuff = new byte[3];//rb.ReadBuff(ref tempReadBuff);//Console.WriteLine(tempReadBuff[0].ToString() + "." + tempReadBuff[1].ToString() + "." + tempReadBuff[2].ToString());//Console.WriteLine(rb.GetBuffInfo());//++testChar;//System.Threading.Thread.Sleep(1000);//}

//随机测试。

//while (true)//{//bool ret = rb.WriteBuff(new byte[] { (byte)testChar, (byte)++testChar, (byte)++testChar });//if (ret == false)//{//--testChar;//--testChar;//--testChar;//}//Console.WriteLine(rb.GetBuffInfo());//Random rd = new Random();//int rint = (rd.Next() + 2) % 10;//byte[] tempReadBuff = new byte[rint];//Console.Write("read " + rint.ToString("x") + " :");//rb.ReadBuff(ref tempReadBuff);//for (int i = 0; i < rint; ++i)//{//Console.Write(tempReadBuff[i].ToString("x") + " ");//}//Console.Write("\r\n");//Console.WriteLine(rb.GetBuffInfo());//++testChar;//System.Threading.Thread.Sleep(1000);//}

Console.Read();

}

179274984_1_20191231042251191.gif

java 版本

明显发现java和c#基本语法就像双胞胎。为什么好多人包括之前的自己，会排斥另一种语言呢?

特定：读完，写满，之后都不工作了。

unusedSize;//冗余这个字段既可以提高效率，也可以区分空还是满的情况(单靠2个指针区分不了)。

179274984_1_20191231042251191.gif

package com.datastructurn;

public class RingBuff

{

private byte[] ringBuff;

private Integer nextWritePosition;

private Integer nextReadPosition;

private Integer buffSize;

private Integer unusedSize;//冗余这个字段既可以提高效率，也可以区分空还是满的情况(单靠2个指针区分不了)。

public RingBuff(int _size)

{

buffSize= unusedSize=_size;

ringBuff=new byte[buffSize];

nextReadPosition=nextWritePosition=0;

}

public boolean WriteBuff(byte[] _buff)

{

boolean ret = false;

int bsize = _buff.length;

if (unusedSize < bsize)

{

ret = false;

}

else

{

int rightLeft = buffSize - nextWritePosition;

//need reture to head

if (bsize > rightLeft)

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, rightLeft);

System.arraycopy(_buff, rightLeft, ringBuff, 0, bsize - rightLeft);

nextWritePosition = bsize - rightLeft;

}

else if (bsize == rightLeft)

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, bsize);

nextWritePosition = 0;

}

else

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, bsize);

nextWritePosition += bsize;

}

unusedSize = unusedSize - bsize;

ret = true;

}

return ret;

}

public boolean WriteBuff(byte[] _buff, int len)

{

int bsize = len;//_buff.Length;

bsize = len > _buff.length ? _buff.length : bsize;

if (unusedSize < bsize)

{

return false;

}

else

{

int rightLeft = buffSize - nextWritePosition;

//need reture to head

if (bsize > rightLeft)

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, rightLeft);

System.arraycopy(_buff, rightLeft, ringBuff, 0, bsize - rightLeft);

nextWritePosition = bsize - rightLeft;

}

else if (bsize == rightLeft)

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, bsize);

nextWritePosition = 0;

}

else

{

System.arraycopy(_buff, 0, ringBuff, nextWritePosition, bsize);

nextWritePosition += bsize;

}

unusedSize -= bsize;

return true;

}

}

///

///读缓存,是否预读，而不移动读哨兵.///

/// 读入的临时缓存

/// 实际读出的数据长度

public int ReadBuff(byte[] readbuff, Boolean MovePosition )

{

if(MovePosition==null)

{

MovePosition=true;

}

int len = readbuff.length;

int enableread = buffSize - unusedSize;

//Array.Clear(readbuff, 0, len);

if (len <= 0 || enableread <= 0)

{

return 0;

}

else

{

int realRead = enableread >= len ? len : enableread;

int rightLeft = buffSize - nextReadPosition;

if (realRead > rightLeft)

{

System.arraycopy(ringBuff, nextReadPosition, readbuff, 0, rightLeft);

System.arraycopy(ringBuff, 0, readbuff, rightLeft, realRead - rightLeft);

if (MovePosition)

{

nextReadPosition = realRead - rightLeft;

}

}

else if (realRead == rightLeft)

{

System.arraycopy(ringBuff, nextReadPosition, readbuff, 0, realRead);

if (MovePosition)

{

nextReadPosition = 0;

}

}

else

{

System.arraycopy(ringBuff, nextReadPosition, readbuff, 0, realRead);

if (MovePosition)

{

nextReadPosition += realRead;

}

}

unusedSize += realRead;

return realRead;

}

}

public String GetBuffInfo()

{

StringBuilder sb = new StringBuilder();

sb.append(":writePositon:" + nextWritePosition);

sb.append(". readPosition:" + nextReadPosition);

sb.append(". size:");

sb.append(buffSize);

sb.append(".enable read:" + (buffSize-unusedSize) + ".enable write:" + unusedSize);

sb.append("\r\n");

sb.append("1-10 byte:");

for (int i = 0; i < 10; i++)

{

sb.append(ringBuff[i]);

}

return sb.toString();

}

}

179274984_1_20191231042251191.gif

共享内存

179274984_1_20191231042251191.gif

using System;

using System.Collections.Generic;

using System.IO;

using System.IO.MemoryMappedFiles;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading.Tasks;

namespace control

{

public class ShareMemory

{

[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]

public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

//int+int+10*10=108int size = Marshal.SizeOf(typeof(char));

public void CreateShareFile(int size)

{

using (var mmf = MemoryMappedFile.CreateFromFile(@"c:\aa.data", FileMode.Open, "test", size+12))

{

//通过指定的 偏移量和大小 创建内存映射文件视图服务器

using (var accessor = mmf.CreateViewAccessor()) //偏移量，可以控制数据存储的内存位置；大小，用来控制存储所占用的空间

{

accessor.Write(0, 16);//nextWritePos

accessor.Write(4, 16);//nextReadPos;

accessor.Write(8, size);//buffSize

accessor.Write(12, size);//capcity

}

}

}

public int GetNextWritePos(MemoryMappedViewAccessor mmv)

{

return mmv.ReadInt32(0);

}

public void SetNextWritePos(MemoryMappedViewAccessor mmv,int value)

{

mmv.Write(0, value);

}

public int GetnextReadPos(MemoryMappedViewAccessor mmv)

{

return mmv.ReadInt32(4);

}

public void SetnextReadPos(MemoryMappedViewAccessor mmv, int value)

{

mmv.Write(4, value);

}

public int GetbuffSize(MemoryMappedViewAccessor mmv)

{

return mmv.ReadInt32(8);

}

public int Getcapcity(MemoryMappedViewAccessor mmv)

{

return mmv.ReadInt32(12);

}

public void Setcapcity(MemoryMappedViewAccessor mmv, int value)

{

mmv.Write(12, value);

}

public IntPtr changepd(byte[] write)

{

IntPtr write_data = Marshal.AllocHGlobal(write.Length);

Marshal.Copy(write, 0, write_data, write.Length);

Marshal.FreeHGlobal(write_data );

return write_data;

}

public bool Write(byte[] _buff)

{

bool ret = false;

using (var mmf = MemoryMappedFile.CreateFromFile(@"c:\aa.data", FileMode.Open, "test", 108))

{

using (var accessor = mmf.CreateViewAccessor())

{

int bsize = _buff.Length;

if (Getcapcity(accessor) < bsize)

{

ret = false;

}

else

{

int rightLeft = GetbuffSize(accessor) - GetnextReadPos(accessor);

if (bsize > rightLeft)

{

unsafe

{

byte* pb = (byte*)IntPtr.Zero;

accessor.SafeMemoryMappedViewHandle.AcquirePointer(ref pb);

CopyMemory((IntPtr)(pb), changepd(_buff), (uint)_buff.Length);

}

//Array.Copy(_buff, 0, ringBuff, nextWritePos, rightLeft);//Array.Copy(_buff, rightLeft, ringBuff, 0, bsize - rightLeft);

SetNextWritePos(accessor, bsize - rightLeft);

}

else if (bsize == rightLeft)

{

//Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

SetNextWritePos(accessor, 16);

}

else

{

//Array.Copy(_buff, 0, ringBuff, nextWritePos, bsize);

SetNextWritePos(accessor,GetnextReadPos(accessor)+bsize);

}

Setcapcity(accessor, Getcapcity(accessor) - bsize);

ret = true;

}

}

}

return ret;

}

}

}

179274984_1_20191231042251191.gif

Miss黑手套
关注
JAVA:实现CircularBuffer环形缓冲器算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-09 567
JAVA:实现CircularBuffer环形缓冲器算法(附完整源码)
环形缓冲区实现类(RingBuffer)
09-01
环形缓冲区实现类(RingBuffer)
环形BUF
nopear6的博客
12-23 244
typedef struct { u8 *pTxBuf; u8 *pRxBuf; u16 read; u16 write; }uartBuff_t; uartBuff_t objUartBuf; void UartBufInit(void) { objUartBuf.read=0; objUartBuf.write=0; objUartBuf.pTxBuf=sim_uart_tx_buf; ob...
java buffer 有什么用_小师妹学JavaIO之:Buffer和Buff
weixin_39593340的博客
02-23 1111
简介小师妹在学习NIO的路上越走越远，唯一能够帮到她的就是在她需要的时候给她以全力的支持。什么都不说了，今天介绍的是NIO的基础Buffer。老铁给我上个Buff。Buffer是什么小师妹：F师兄，这个Buffer是我们纵横王者峡谷中那句：老铁给我加个Buff的意思吗？当然不是了，此Buffer非彼Buff，Buffer是NIO的基础，没有Buffer就没有NIO，没有Buffer就没有今天的ja...
C环形buff
213的博客
06-21 720
图解释 结构体 typedef struct byteQueue_s { char* pBuffer;//数据 size_t nCapacity;//容量 size_t nReadIndex;//读指针索引 size_t nWriteIndex;//写指针索引 } byteQueue_tt; 初始 结构体 假设要申请的空间 环形buff结构体大小为8 nWriteIndex 写指针索引 nReadIndex 读指针索引 环形buff初始化 void byteQueue_init(byteQu
java buff_java file/bytebuff
热门推荐
weixin_39655377的博客
02-23 2万+
import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.RandomAccessFile;import java.nio.ByteBuffer;import java.ni...
COM_IN_INT.rar_51环形缓冲区_串口 缓冲区_环形 单片机_环形缓冲区51_环形队列
09-21
在51单片机的串口通信中，使用环形缓冲区作为输入缓冲区可以提高数据处理的效率和稳定性。本文将详细解释环形缓冲区的概念、设计原理以及在串口中断方式下的应用。 首先，让我们理解什么是环形缓冲区。环形缓冲区，...
CircleQueue_with_array_list.rar_c环形队列_环形缓冲区_环形队列_缓冲 队列
09-14
无论是数组还是链表，环形队列和环形缓冲区都是高效的数据管理工具，对于处理大量数据流或进行多线程通信的系统具有重要意义。通过分析和实践这些代码，我们可以深入理解环形数据结构的原理和优势，并将其应用到实际...
环形缓冲区的实现.rar_STM32使用环形缓冲区去接收和发送数据_hatyke_环形缓冲_环形缓冲区_环形缓冲区32
07-14
STM32使用环形缓冲区去接收和发送数据，值得收藏，很经典。
xunhuan.rar_visual c_xunhuan _环形缓冲_环形缓冲区
09-19
环形缓冲区（Circular Buffer）是一种在内存中高效管理数据流的结构，广泛应用于各种实时系统和嵌入式系统中。在计算机编程中，尤其是在处理数据传输、音频处理、网络通信等领域，环形缓冲区的设计与实现是至关重要...
RingBuffer.rar_RINGBUFFER_环形缓冲_环形缓冲区
07-14
环形缓冲区，环形缓冲区在数据采集等实时系统中广泛使用。
protocol buff java
03-01
protocol buff java pb
03_环形buff
Chockong的博客
06-09 188
把接收到的数据先填到环形buff里面。 #define bleRINGBUFF_LEN 128 typedef struct { uint8 Head; uint8 Tail; uint8 Lenght; uint8 bleRing_Buff[bleRINGBUFF_LEN]; }bleRingBuff_t;//环形buff结构体 //======================================= //写ble环形buff uint8 ble
串口监听大量数据匹配处理--利用环形buff
weixin_45146364的博客
01-12 493
功能描述： A和B设备之间在串口通信，C设备利用串口去监听A和B的通信，我们将要监听的字段给到C，C将匹配到的字段数据保存下来。 实现方法： 利用线性数组将头尾连起来，形成一个环形的buff来接收串口中断的数据。 关键点： buff判满不再接收数据，否则尾指针移动tail++ (tail+1)%maxsize = head 尾指针达到最大置0： tail>=maxsize tail=0; buff中数据个数： (tail -head+maxsize)%maxsize 要确保数据个数要大于匹配的字段长度
Java的循环队列(环形缓冲、RingBuffer)
学一次的博客
05-05 1887
RingBuffer好处线程安全，可以边写边读。 创建一个循环队列（环形缓冲、RingBuffer），实际元素存在一个数组中，操作数组的指针，不移动元素。
无锁环形缓冲RingBuffer的原理及Java实现
pengjianglilive的专栏
11-03 1785
在多线程环境下为了保证线程安全，往往需要加锁，例如读写锁可以保证读写互斥，读读不互斥。有没有一种数据结构能够实现无锁的线程安全呢？答案就是使用RingBuffer循环队列。在Disruptor项目中就运用到了RingBuffer。 RingBuffer的基本原理如下： 在RingBuffer中设置了两个指针，head和tail。head指向下一次读的位置，tail指向的是下一次写的位置。RingBuffer可用一个数组进行存储，数组内元素的内存地址是连续的，这是对CPU缓存友好的——也就是说，在硬件级别
[缓存] RingBuff 环形队列、环形缓冲区及有锁无锁实现
最新发布
小田的专栏
02-20 1762
由于自旋锁不需要进行线程切换，所以它完全在用户态下实现，加锁开销低，但是由于其采用忙等待的策略，对于短期加锁来说没问题，但是长期锁定的时候就会导致CPU资源的大量消耗。如果读取数据的速度跟不上写入数据的速度，旧的数据将被新写入的数据覆盖。所以当互斥锁加锁失败的时候，就伴随着两次上下文切换的开销，而如果我们锁定的时间较短，可能上下文切换的时间会比锁定的时间还要长。由于自旋锁和互斥锁的失败策略不同，自旋锁采用忙等待的策略，而互斥锁采用线程切换的策略，由于策略不同，它们的应用场景也不同。
算法：基于RingBuffer的高效环形数组
hahackeris的专栏
06-22 401
算法 环形数组 ringbuffer
buffer java_Java学习之buffer
weixin_42558257的博客
02-22 460
1.类介绍①线程安全的可变字符串序列，一个类似于String的字符串缓冲区，但是不能修改(就是不能通过加号+连接，String就可以)②StringBuffer和String类的区别String是一个可改变的字符序列StringBuffer是一个可变的字符序列2.构造方法StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符StringBuffer(int capac...
生产者消费者模式：环形缓冲区策略与优化
在实现环形缓冲区时，为了减少内存分配和释放的开销，通常选择存储值类型的数据，而不是指针或引用类型的数据。值类型的数据存储可以直接在缓冲区中完成，而不需要额外的堆内存分配，从而更好地体现环形缓冲区的效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值