C#的多线程锁定问题
大家好，我在学习C#多线程编程时遇到了下面的问题。
我建立了三个线程，一个生产者Producer和两个消费者Consumer，在HoldIntegerSync的内部对多线程读取与写入进行同步，但是为什么我在HoldIntegerSync的get和set中的lock锁定不起作用呢？所有线程都能同时进入被lock包裹的代码。

C# code

 
 using System; 
 using System.Collections.Generic; 
 using System.Text; 
 using System.Threading; 
  
 namespace ConsoleApplication2 
 { 
     public class Program 
     { 
         static void Main(string[] args) 
         { 
             Console.WriteLine("Main Start."); 
  
             try 
             { 
                 HoldIntegerSync his = new HoldIntegerSync(); 
                 Consumer consumer = new Consumer(his); 
                 Consumer consumerTwo = new Consumer(his); 
  
                 Producer producer = new Producer(his); 
  
                 Thread producerThread = new Thread(new ThreadStart(producer.Produce)); 
                 producerThread.Name = "Producer"; 
  
                 Thread consumerThread1 = new Thread(new ThreadStart(consumer.Consume)); 
                 consumerThread1.Name = "Consumer"; 
  
                 Thread consumerThread2 = new Thread(new ThreadStart(consumerTwo.Consume)); 
                 consumerThread2.Name = "ConsumerTwo"; 
  
                 consumerThread1.Start(); 
                 consumerThread2.Start(); 
                 producerThread.Start(); 
  
             } 
             catch (Exception e) 
             { 
                 Console.WriteLine("Catch Exception : \n" + e.ToString()); 
  
                 Console.WriteLine("Exception Message : \n" + e.Message); 
  
                 Console.WriteLine("Exception Inner :\n" + e.InnerException); 
             } 
  
             Console.WriteLine("Main End."); 
         } 
     } 
  
     class Producer 
     { 
         private Random rd = new Random(10); 
          
         private HoldIntegerSync sync; 
         public Producer(HoldIntegerSync his) 
         { 
             this.sync = his; 
         } 
  
         public void Produce() 
         { 
             sync.Buffer = rd.Next(); 
         } 
     } 
  
     class Consumer 
     { 
         private HoldIntegerSync sync; 
         public Consumer(HoldIntegerSync his) 
         { 
             this.sync = his; 
         } 
  
         public void Consume()  
 
         { 
             Console.WriteLine(Thread.CurrentThread.Name + " read: {0}", sync.Buffer); 
         } 
     } 
  
     class HoldIntegerSync 
     { 
         private int count = 0; 
  
         private int _Buffer; 
  
         public int Buffer 
         { 
             get 
             { 
                 lock (this) 
                 { 
                     Console.WriteLine(Thread.CurrentThread.Name + " Enter lock."); 
                     if (count == 0) 
                     { 
                         Console.WriteLine(Thread.CurrentThread.Name + " waiting read."); 
                         Monitor.Wait(this); 
                     } 
  
                     Console.WriteLine(Thread.CurrentThread.Name + " reading:{0}", _Buffer); 
  
                     count--; 
  
                     Monitor.PulseAll(this);                     
                 } 
  
                 Console.WriteLine(Thread.CurrentThread.Name + " Exit lock."); 
  
                 return _Buffer; 
             } 
  
             set 
             { 
                 lock (this) 
                 { 
                     Console.WriteLine(Thread.CurrentThread.Name + " Enter lock"); 
                     if (count == 1) 
                     { 
                         Console.WriteLine(Thread.CurrentThread.Name + " waiting write."); 
                         Monitor.Wait(this); 
                     } 
  
                     Console.WriteLine(Thread.CurrentThread.Name + " writing:{0}", value); 
  
                     _Buffer = value; 
  
                     count++; 
  
                     Monitor.PulseAll(this);                     
                 } 
  
                 Console.WriteLine(Thread.CurrentThread.Name + " Exit lock."); 
             } 
         } 
     } 
  
 } 
  
 

Monitor.Wait(object);
释放对象上的锁并阻止当前线程，直到它重新获取该锁。
[解决办法]
你要加排他锁，才能在同一时间由一个进程来访问。
[解决办法]
应用双锁来锁定。。。。