能否通过 C# 线程同步以原子方式发出信号并等待？

Question

我在 C# 中的线程同步方面遇到一些问题。我有一个由两个线程操纵的共享对象，我已经使用 lock() 互斥地访问了该对象，但我也想根据共享对象的状态来阻止每个线程。特别是当对象为空时阻塞线程 A，当对象已满时阻塞线程 B，并在对象状态更改时让另一个线程向被阻塞的线程发出信号。

我尝试使用 ManualResetEvent 执行此操作，但遇到了竞争条件，其中线程 B 将检测到对象已满，移至 WaitOne，线程 A 将进入并清空对象（每次访问时向 MRE 发出信号，并阻止自身一次）在线程 A 到达其 WaitOne 之前，对象为空），这意味着线程 A 正在等待线程未满，即使它尚未满。

我想如果我可以调用像“SignalAndWaitOne”这样的函数，它会在等待之前自动发出信号，这会阻止这种竞争条件吗？

谢谢！

Answer 1

执行此操作的典型方法是使用 Monitor.Enter、Monitor.Wait 和 Monitor.Pulse 来控制对共享队列的访问。草图：

shared object sync = new object()
shared Queue q = new Queue()

Producer()
    Enter(sync)
    // This blocks until the lock is acquired
    while(true)
        while(q.IsFull)
            Wait(sync)     
            // this releases the lock and blocks the thread 
            // until the lock is acquired again

        // We have the lock and the queue is not full.
        q.Enqueue(something)
        Pulse(sync)
        // This puts the waiting consumer thread to the head of the list of 
        // threads to be woken up when this thread releases the lock

Consumer()
    Enter(sync)
    // This blocks until the lock is acquired
    while(true)
        while(q.IsEmpty)
            Wait(sync)
            // this releases the lock and blocks the thread 
            // until the lock is acquired again

        // We have the lock and the queue is not empty.
        q.Dequeue()
        Pulse(sync)
        // This puts the waiting producer thread to the head of the list of 
        // threads to be woken up when this thread releases the lock

Answer 2

.NET 已提供 BlockingCollection 4.0。

如果您使用的是早期版本，则可以使用 < code>直接监视类。

编辑：以下代码完全未经测试，并且不处理较小的 maxCount 值 (<= 2)。它也没有任何超时或取消的规定：

public sealed class BlockingList<T>
{
  private readonly List<T> data;
  private readonly int maxCount;

  public BlockingList(int maxCount)
  {
    this.data = new List<T>();
    this.maxCount = maxCount;
  }

  public void Add(T item)
  {
    lock (data)
    {
      // Wait until the collection is not full.
      while (data.Count == maxCount)
        Monitor.Wait(data);

      // Add our item.
      data.Add(item);

      // If the collection is no longer empty, signal waiting threads.
      if (data.Count == 1)
        Monitor.PulseAll(data);
    }
  }

  public T Remove()
  {
    lock (data)
    {
      // Wait until the collection is not empty.
      while (data.Count == 0)
        Monitor.Wait(data);

      // Remove our item.
      T ret = data.RemoveAt(data.Count - 1);

      // If the collection is no longer full, signal waiting threads.
      if (data.Count == maxCount - 1)
        Monitor.PulseAll(data);
    }
  }
}