Variables de condición en C#

Question

¿Están las variables de condición & monitores utilizados en C#?

¿Alguien me puede dar un ejemplo?

Answer 1

El equivalente de una condición variable que se utiliza sólo para la señalización en .NET es la clase WaitHandle abstracto. Implementaciones prácticas de él son las clases ManualResetEvent y AutoResetEvent.

Una variable de condición que utilice como monitor requiere System.Threading.Monitor. La instrucción C# lock hace que sea muy fácil de usar, asegura que el monitor siempre salga sin programar explícitamente la llamada Exit().

Answer 2

Puede usar el objeto Lock que actúa como azúcar sintáctico para la clase Monitor.

lock(someObject) 
{ 
    // Thread safe code here. 
} 

http://msdn.microsoft.com/en-us/library/c5kehkcz%28VS.80%29.aspx

Answer 3

System.Threading.Monitor es una manera (ejemplo dentro)

Answer 4

Como alternativa a ManualResetEvent y sus amigos, Windows ahora proporciona native support para las variables de condición. No he realizado una evaluación comparativa yo mismo, pero hay muchas posibilidades de que mejore su rendimiento al aprovechar la API nativa.

Aquí es un artículo de código del proyecto que explica cómo acceder a esta (relativamente nuevo) construir a partir de C#:

A .NET Wrapper for the Vista/Server 2008 Condition Variable

Answer 5

Esta versión desbloquea atómicamente un mutex o ReaderWriterLockSlim a la espera de señalización, y vuelve a cerrar antes de volver - que es la forma posix.

using System.Collections.Concurrent; 

namespace System.Threading.More { 
    public class ConditionVariable { 
     private readonly ConcurrentQueue<ManualResetEventSlim> _waitingThreads = new ConcurrentQueue<ManualResetEventSlim>(); 

     /// <summary> 
     ///  Atomically unlocks and waits for a signal. 
     ///  Then relocks the mutex before returning 
     /// </summary> 
     /// <param name="mutex"></param> 
     public void Wait(Mutex mutex) { 
      if (mutex == null) { 
       throw new ArgumentNullException("mutex"); 
      } 
      var waitHandle = new ManualResetEventSlim(); 
      try { 
       _waitingThreads.Enqueue(waitHandle); 
       mutex.ReleaseMutex(); 
       waitHandle.Wait(); 
      } finally { 
       waitHandle.Dispose(); 
      } 
      mutex.WaitOne(); 
     } 

     public void WaitRead(ReaderWriterLockSlim readerWriterLock) { 
      if (readerWriterLock == null) { 
       throw new ArgumentNullException("readerWriterLock"); 
      } 
      var waitHandle = new ManualResetEventSlim(); 
      try { 
       _waitingThreads.Enqueue(waitHandle); 
       readerWriterLock.ExitReadLock(); 
       waitHandle.Wait(); 
      } finally { 
       waitHandle.Dispose(); 
      } 
      readerWriterLock.EnterReadLock(); 
     } 

     public void Signal() { 
      ManualResetEventSlim waitHandle; 
      if (_waitingThreads.TryDequeue(out waitHandle)) { 
       waitHandle.Set(); 
      } 
     } 

     public void Broadcast() { 
      ManualResetEventSlim waitHandle; 
      while (_waitingThreads.TryDequeue(out waitHandle)) { 
       waitHandle.Set(); 
      } 
     } 
    } 
}