C# 创建实现读写方法的同步数组

我有一个类，它包含以下字段：消息数组、当前消息数和读\写方法

当有人写入时，它会将消息放入数组中，并将当前消息数增加1，而当有人试图首先读取消息时，则会减少
当前消息数，然后返回最后一条消息

我想让这个类被同步，这样它将允许线程从他那里写入和读取（当数组为空时，我希望线程将等待，直到有东西要读取），并防止数据争用

我完成了这个类，它实现了：

   class SynchronizedDATAStructure : DATAStructure
{
    private Mutex mutexR = new Mutex();
    private Mutex mutexW = new Mutex();
    private Semaphore semaphore = new Semaphore(0, int.MaxValue);
    private Semaphore semaphore2 = new Semaphore(1, 1);

    public override void Write(Message msg)
    {
        mutexW.WaitOne(); // allows only one thread each time to write
        semaphore2.WaitOne(); // checks if nobody is reading 
        base.Write(msg); // writing
        semaphore.Release(); // counts number of messages
        semaphore2.Release(); // finish to write
        mutexW.ReleaseMutex(); // finish the function
    }

    public override Message Read()
    {
        mutexR.WaitOne(); // allows only one thread each time to read
        semaphore.WaitOne();  // checks if there  are messages 
        semaphore2.WaitOne(); // checks if nobody is writing 
        Message msg1 = base.Read(); // reading
        semaphore2.Release(); // finish to read
        mutexR.ReleaseMutex(); // finish the function
        return msg1; // returns the messge
    }

---

当线程开始写入\读取时，当线程尝试从空数组读取时，我从边界中退出。

您可以使用

监视器使代码更加简单：

class SynchronizedDATAStructure : DATAStructure
{
    private readonly object syncRoot = new object();

    public int MessageCount { get; private set; }

    public override void Write(Message msg)
    {
        lock (syncRoot)
        {
            base.Write(msg);
            MessageCount++;

            Monitor.Pulse(syncRoot);
        }
    }

    public override Message Read()
    {
        lock (syncRoot)
        {
            while (MessageCount <= 0)
            {
                Monitor.Wait(syncRoot);
            }

            MessageCount--;
            return base.Read();
        }
    }
}

类同步数据结构：数据结构
{
私有只读对象syncRoot=新对象（）；
public int MessageCount{get；private set；}
公共覆盖无效写入（消息消息消息）
{
锁定（同步根）
{
base.Write（msg）；
MessageCount++；
监视器。脉冲（同步根）；
}
}
公共覆盖消息读取（）
{
锁定（同步根）
{
虽然（MessageCount）代码不必要的复杂，但我看不出它有什么明显的问题。我怀疑你的问题在别处