c# 同步功能的环形缓存区ReadWrite RingBuffer

最新推荐文章于 2024-07-16 11:16:37 发布
翻译 最新推荐文章于 2024-07-16 11:16:37 发布 · 2.9k 阅读 · 1
文章标签：

#FIFO环形缓存区 #c# #缓存

本文介绍了一种基于简单同步机制的读写环形缓冲区的实现细节，该缓冲区支持多线程环境下数据的读取与写入操作，并通过示例展示了其基本使用方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

// Define this to use simple synchronisation rather than events.
// They are about the same in terms of speed.
#define SimpleSynch

using System;
using System.IO;
using System.Threading;

using NUnit.Framework;


namespace ICSharpCode.SharpZipLib.Tests.TestSupport
{
	/// <summary>
	/// A fixed size buffer of bytes.  Both reading and writing are supported.
    /// Reading from an empty buffer will wait until data is written.  Writing to a full buffer
    /// will wait until data is read.
	/// </summary>
	public class ReadWriteRingBuffer
    {
        #region Constructors
        /// <summary>
		/// Create a new RingBuffer with a specified size.
		/// </summary>
		/// <param name="size">The size of the ring buffer to create.</param>
		public ReadWriteRingBuffer( int size )
		{
			if ( size <= 0 ) {
				throw new ArgumentOutOfRangeException( "size" );
			}

			array_ = new byte[size];
            lockObject_ = new object();

#if SimpleSynch
            waitSpan_ = TimeSpan.FromMilliseconds(1);
#else
            notEmptyEvent_ = new ManualResetEvent(false);
            notFullEvent_ = new ManualResetEvent(true);
#endif
        }
        #endregion

        /// <summary>
		/// Clear the buffer contents.
		/// </summary>
		public void Clear()
		{
			tail_ = 0;
			head_ = 0;
			count_ = 0;

			Array.Clear( array_, 0, array_.Length );

#if !SimpleSynch
            notFullEvent_.Set();
            notEmptyEvent_.Reset();
#endif
		}

        /// <summary>
        /// Close the buffer for writing.
        /// </summary>
        /// <remarks>A Read when the buffer is closed and there is no data will return -1.</remarks>
        public void Close()
        {
            isClosed_ = true;
#if !SimpleSynch
            notEmptyEvent_.Set();
#endif
        }

		/// <summary>
		/// Write adds a byte to the head of the RingBuffer.
		/// </summary>
		/// <param name="value">The value to add.</param>
		public void WriteByte( byte value )
		{
            if (isClosed_) {
                throw new Exception("Buffer is closed");
            }

#if SimpleSynch
            while (IsFull) {
              Thread.Sleep(waitSpan_);
            }
#else            
            notFullEvent_.WaitOne();
#endif

            lock (lockObject_) {
                array_[head_] = value;
                head_ = (head_ + 1) % array_.Length;

#if !SimpleSynch
                bool setEmpty = (count_ == 0);
#endif

                count_ += 1;

#if !SimpleSynch
                if (IsFull)
                {
                    notFullEvent_.Reset();
                }

                if (setEmpty)
                {
                    notEmptyEvent_.Set();
                }
#endif
            }

            bytesWritten_++;
		}

        public void Write(byte[] buffer, int index, int count)
        {
            if (isClosed_)
            {
                throw new Exception("Buffer is closed");
            }

            while ( count >  0 )
            {
#if SimpleSynch
                while (IsFull) {
                    Thread.Sleep(waitSpan_);
                }
#else            
                notFullEvent_.WaitOne();
#endif

                // Gauranteed to not be full at this point, however readers may sill read
                // from the buffer first.
                lock (lockObject_)
                {
                    int bytesToWrite = Length - Count;

                    if (count < bytesToWrite)
                    {
                        bytesToWrite = count;
                    }
#if !SimpleSynch
                    bool setEmpty = (count_ == 0);
#endif

                    while (bytesToWrite > 0)
                    {
                        array_[head_] = buffer[index];
                        index++;

                        head_ = (head_ + 1) % array_.Length;

                        bytesToWrite--;
                        bytesWritten_++;
                        count--;
                        count_++;
                    }

#if !SimpleSynch
                    if (IsFull)
                    {
                        notFullEvent_.Reset();
                    }

                    if (setEmpty)
                    {
                        notEmptyEvent_.Set();
                    }
#endif
                }
            }
        }

        /// <summary>
        /// Read a byte from the buffer.
        /// </summary>
        /// <returns></returns>
        public int ReadByte()
        {
            int result = -1;

#if SimpleSynch
            while (!isClosed_ && IsEmpty) {
                Thread.Sleep(waitSpan_);
            }
#else
            notEmptyEvent_.WaitOne();
#endif

            if ( !IsEmpty ) {
                lock (lockObject_) {
                    result = array_[tail_];
                    tail_ = (tail_ + 1) % array_.Length;
#if !SimpleSynch
                    bool setFull = IsFull;
#endif
                    count_ -= 1;
#if !SimpleSynch
                    if (!isClosed_ && (count_ == 0))
                    {
                        notEmptyEvent_.Reset();
                    }

                    if (setFull)
                    {
                        notFullEvent_.Set();
                    }
#endif
                }
            }

            bytesRead_++;

            return result;
        }

        public int Read(byte[] buffer, int index, int count)
        {
            int result = 0;

            while (count > 0)
            {
#if SimpleSynch
                while (!isClosed_ && IsEmpty)
                {
                    Thread.Sleep(waitSpan_);
                }
#else
                notEmptyEvent_.WaitOne();
#endif

                if (IsEmpty)
                {
                    count = 0;
                }
                else
                {
                    lock (lockObject_)
                    {
                        int toRead = Count;

                        if (toRead > count)
                        {
                            toRead = count;
                        }

                        result += toRead;

#if !SimpleSynch
                        bool setFull = IsFull;
#endif

                        while (toRead > 0)
                        {
                            buffer[index] = array_[tail_];
                            index++;

                            tail_ = (tail_ + 1) % array_.Length;
                            count--;
                            count_--;
                            toRead--;
                            bytesRead_++;
                        }
#if !SimpleSynch
                        if (!isClosed_ && (count_ == 0))
                        {
                            notEmptyEvent_.Reset();
                        }

                        if (setFull)
                        {
                            notFullEvent_.Set();
                        }
#endif
                    }
                }
            }

            return result;
        }

		#region Properties

		/// <summary>
		/// Gets a value indicating wether the buffer is empty or not.
		/// </summary>
		public bool IsEmpty
		{
			get { return count_ == 0; }
		}

        public bool IsFull
        {
            get {
                return (count_ == array_.Length);
            }
        }

        public bool IsClosed
        {
            get { return isClosed_; }
        }

		/// <summary>
		/// Gets the number of elements in the buffer.
		/// </summary>
		public int Count
		{
			get {
				return count_;
			}
		}


        public int Length
        {
            get { return array_.Length; }
        }

        public long BytesWritten
        {
            get { return bytesWritten_; }
        }

        public long BytesRead
        {
            get { return bytesRead_; }
        }

        /// <summary>
		/// Indexer - Get an element from the tail of the RingBuffer.
		/// </summary>
		public byte this[ int index ]
		{
			get {
				if ( ( index < 0 ) || ( index >= array_.Length ) ) {
					throw new ArgumentOutOfRangeException( "index" );
				}

				return array_[ ( tail_ + index ) % array_.Length ];
			}
		}

		#endregion

		#region Instance Variables
        /// <summary>
        /// Flag indicating the buffer is closed.
        /// </summary>
        bool isClosed_;

		/// <summary>
		/// Index for the head of the buffer.
		/// </summary>
        /// <remarks>Its the index of the next byte to be <see cref="Write">written</see>.</remarks>
		int head_;

		/// <summary>
		/// Index for the tail of the buffer.
		/// </summary>
        /// <remarks>Its the index of the next byte to be <see cref="Read">written</see>.</remarks>
        int tail_;

		/// <summary>
		/// The total number of elements added to the buffer.
		/// </summary>
		int count_;

		/// <summary>
		/// Storage for the ring buffer contents.
		/// </summary>
		byte[] array_;

        long bytesWritten_;
        long bytesRead_;

        object lockObject_;

        TimeSpan waitSpan_;

#if !SimpleSynch
        ManualResetEvent notEmptyEvent_;
        ManualResetEvent notFullEvent_;
#endif
		#endregion
	}

    [TestFixture]
    public class ExerciseBuffer
    {
        [Test]
        public void Basic()
        {
            const int Size = 64;

            buffer_ = new ReadWriteRingBuffer(Size);

            Assert.IsFalse(buffer_.IsFull);
            Assert.IsTrue(buffer_.IsEmpty);

            buffer_.WriteByte(1);

            Assert.IsFalse(buffer_.IsFull);
            Assert.IsFalse(buffer_.IsEmpty);
            Assert.AreEqual(1, buffer_.Count);

            Assert.AreEqual(1, buffer_.ReadByte());

            Assert.IsFalse(buffer_.IsFull);
            Assert.IsTrue(buffer_.IsEmpty);

            for (int i = 0; i < buffer_.Length; ++i)
            {
                buffer_.WriteByte(unchecked((byte)(i & 0xff)));
            }

            Assert.IsTrue(buffer_.IsFull);
            Assert.IsFalse(buffer_.IsEmpty);

            buffer_.Close();

            Assert.IsTrue(buffer_.IsClosed);

            bool caught = false;
            try
            {
                buffer_.WriteByte(1);
            }
            catch
            {
                caught = true;
            }

            Assert.IsTrue(caught);

            int count = Size;
            int expected = 0;

            while (count != 0)
            {
                Assert.AreEqual(count, buffer_.Count);
                Assert.AreEqual(expected, buffer_.ReadByte());
                count--;
                expected = (expected + 1) & 0xff;
            }

            Assert.IsTrue(buffer_.IsEmpty);
            Assert.AreEqual(-1, buffer_.ReadByte());
        }

        [Test]
        public void Buffered()
        {

            const int Size = 64;

            buffer_ = new ReadWriteRingBuffer(Size);

            byte[] writeBuffer = new byte[16];
            for (int i = 0; i < 16; ++i)
            {
                writeBuffer[i] = (byte)i;
            }

            buffer_.Write(writeBuffer, 0, 3);
            Assert.AreEqual(3, buffer_.Count);

            byte[] readBuffer = new byte[16];
            Assert.AreEqual(3, buffer_.Read(readBuffer, 0, 3));
            for (int i = 0; i < 3; ++i)
            {
                Assert.AreEqual(i, readBuffer[i]);
            }

        }

        [Test]
        public void Threaded()
        {
            buffer_ = new ReadWriteRingBuffer(8);
            readTarget_ = writeTarget_ = 16384;

            Thread reader = new Thread(Reader);
            reader.Start();

            Thread writer = new Thread(Writer);
            writer.Start();

            writer.Join();
            reader.Join();
        }

        void Reader()
        {
            Random r = new Random();
            byte nextValue = 0;

            while (readTarget_ > 0)
            {
                int thisTime = r.Next(16);
                if (thisTime > readTarget_)
                {
                    thisTime = readTarget_;
                }

                while (thisTime > 0)
                {
                    int readValue = buffer_.ReadByte();
                    Assert.AreEqual(nextValue, readValue);
                    nextValue = (byte)((nextValue + 1) & 0xff);
                    thisTime--;
                    readTarget_--;
                }

                Thread.Sleep(r.Next(10));

            }

            int last = buffer_.ReadByte();

            Assert.AreEqual(-1, last);
            Assert.IsTrue(buffer_.IsClosed);
        }

        void Writer()
        {
            Random r = new Random();

            byte nextValue = 0;
            while (writeTarget_ > 0)
            {
                int thisTime = r.Next(16);
                if (thisTime > writeTarget_)
                {
                    thisTime = writeTarget_;
                }

                while (thisTime > 0)
                {
                    buffer_.WriteByte(nextValue);
                    nextValue = (byte)((nextValue + 1) & 0xff);
                    thisTime--;
                    writeTarget_--;
                }
                Thread.Sleep(r.Next(10));
            }
            buffer_.Close();
        }

        int readTarget_;
        int writeTarget_;

        ReadWriteRingBuffer buffer_;

    }
}

C#高速环形缓存 生产者消费者模式 线程安全
05-11
这是一个基本的生产者消费者模式的环形缓存器，具有线程安全性，可同时写入和读取，非装箱拆箱操作，高性能大数据可使用此缓存器。
C# Ringbuffer 实现+cacheline不同写法性能测试
weixin_56766616的博客
12-08 687
不同内存布局的ringbuffer性能测试
C#中FileStream——循环RingBuffer
小孔明的专栏
07-22 323
http://blog.sina.com.cn/s/blog_a317eab90102v8vj.html
C#网口数据处理-环形缓冲区
qq_27474555的博客
07-18 613
在C#中用环形数据缓冲区对网口数据进行处理
C#环形缓冲区（队列）完全实现（转）
道可盗经常盗
03-10 1425
以下为原文。
使用环形缓冲区ringbuffer实现串口数据接收
热门推荐
luobeihai的博客
08-26 1万+
文章介绍了环形缓冲区（ringbuffer），以及使用C语言实现了 ringbuffer 的代码。并且在串口接收数据中，使用了 ringbuffer 来保存串口接收的数据。最后，测试了使用 ringbuffer 接收串口数据是否出现丢包现象，以及什么情况下会出现丢包。...
环形缓冲区（Ring Buffer）使用说明
爬坡的小蜗牛的博客
07-22 7535
源码功能包含：实现环形缓冲区的初始函数；实现环形缓冲区是否为空、是否满功能；实现环形缓冲区读写功能。
嵌入式C基础——循环队列 ringbuffer 讲解
weixin_37620587的博客
04-06 3012
ringbuffer的原理讲解以及rtos例子，还有实际举例
环形字节缓冲区源代码实现及其多线程同步机制
在描述中提到的“多线程同步访问锁”，意味着这个环形字节缓冲区类实现了某种形式的同步机制，例如互斥锁（Mutexes）、读写锁（Read-Write Locks）等，确保在读写操作时，数据不会发生冲突。 ### 知识点三：通信...
C# 设计一个可变长度的数据通信协议编码和解码代码。
最新发布
m0_46973223的博客
07-16 494
要有本机ID字段，远端设备ID字段，指令类型字段，数据体字段，校验字段。其中一个要求是，每次固定收发八个字节，单个数据帧超过八个字节需要分包收发。对接收的数据帧要先存入环形缓存区，解码函数需要对环形缓存区中的协议数据持续解码，直到没有数据。解析出的数据最后逐个列出来，验证对错。对于存在的丢包问题，要求有重发机制。设计一个可变长度的数据通信协议编码和解码代码。
C#环形缓冲区（队列）完全实现
09-01
主要为大家详细介绍了C#环形缓冲区（队列）完全实现代码，感兴趣的小伙伴们可以参考一下
c#环形内存缓冲区源码
10-11
频繁操作内存时为防止内存碎片可使用这个环形缓冲区。
CircularBuffer-CSharp:C＃中循环缓冲区的简单单一文件实现
05-01
循环缓冲区 在C＃中简单实现循环缓冲区。 这是单个文件的实现，这意味着您只需要将CircularBuffer.cs文件复制到您的项目中并使用它即可。 什么是循环缓冲区？ 循环缓冲区，循环缓冲区或环形缓冲区是一种数据结构，它使用单个固定大小的缓冲区，就像端到端连接一样。 这意味着您具有预定义的内存使用情况。 推和弹出操作始终为O（1）。 索引访问也是O（1）。 更多信息@ Wikipedia： :
环形缓冲区实现类(RingBuffer)
09-01
环形缓冲区实现类(RingBuffer)
环形缓冲区（RingBuffer）源码
07-22
1、源码已实测可用。 2、源码功能包含：实现环形缓冲区的初始函数；实现环形缓冲区是否为空、是否满功能；实现环形缓冲区读写功能。 3、使用人群：软件工程师、在校大学生、教师等软件开发人员。
环形缓存(C#版)
LH806732的专栏
06-06 7617
想了一想，既然连厌恶的android平台都测试了环形缓存，不能冷落了windows。 C#源码： /// /// 环形缓冲区 /// 一. 写数据: /// 1. push: 当数据已写满时返回false，否则可以正常写入返回true /// 2. pushNoCaseFull: 不管缓冲区是否已写满或当前位置数据是否已读取过，都会写入，不关心读/写指针位置 ///
环形队列缓存(C#版)
Jave.Lin 的学习笔记
12-28 1536
代码 /// <summary> /// author : jave.lin /// date : 2017-12-28 /// </summary> static void Main(string[] args) { // 测试环形缓存 _testingCi
RingBuffer
yhf_szb的专栏
03-20 748
////// 变长的RingBuffer///private class RingBuffer{byte[] _buffer;int _read;int _write;int _count;//有效数据长度////// 缓存区总长度//////protected int length{get{lock ( this . _buffer . SyncRoot ){return this . _buff
C#实现环形缓冲(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-04 128
C#实现环形缓冲(附完整源码)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值