Leichte Alternative zu Manual/AutoResetEvent in C#

Question

Ich habe geschrieben, was ich hoffe, ist eine leichte Alternative zur Verwendung der ManualResetEvent und AutoResetEvent-Klassen in C# /. NET. Der Grund dafür war eine Event-ähnliche Funktionalität ohne die Verwendung eines Kernel-Sperrobjekts.

Obwohl der Code sowohl im Test als auch in der Produktion gut zu funktionieren scheint, kann es eine schwierige Aufgabe sein, diese Art von Ding für alle Möglichkeiten in Ordnung zu bringen und demnächst konstruktive Kommentare und Kritik von StackOverflow zu erbitten. Hoffentlich (nach Überprüfung) wird dies für andere nützlich sein.

Die Verwendung sollte ähnlich wie die Manual/AutoResetEvent-Klassen sein, wobei Notify() für Set() verwendet wird.

Hier geht:

using System; 
using System.Threading; 

public class Signal 
{ 
    private readonly object _lock = new object(); 
    private readonly bool _autoResetSignal; 
    private bool _notified; 

    public Signal() 
    : this(false, false) 
    { 
    } 

    public Signal(bool initialState, bool autoReset) 
    { 
    _autoResetSignal = autoReset; 
    _notified = initialState; 
    } 

    public virtual void Notify() 
    { 
    lock (_lock) 
    { 
     // first time? 
     if (!_notified) 
     { 
     // set the flag 
     _notified = true; 

     // unblock a thread which is waiting on this signal 
     Monitor.Pulse(_lock); 
     } 
    } 
    } 

    public void Wait() 
    { 
    Wait(Timeout.Infinite); 
    } 

    public virtual bool Wait(int milliseconds) 
    { 
    lock (_lock) 
    { 
     bool ret = true; 
     // this check needs to be inside the lock otherwise you can get nailed 
     // with a race condition where the notify thread sets the flag AFTER 
     // the waiting thread has checked it and acquires the lock and does the 
     // pulse before the Monitor.Wait below - when this happens the caller 
     // will wait forever as he "just missed" the only pulse which is ever 
     // going to happen 
     if (!_notified) 
     { 
     ret = Monitor.Wait(_lock, milliseconds); 
     } 

     if (_autoResetSignal) 
     { 
     _notified = false; 
     } 
     return (ret); 
    } 
    } 
} 

Answer 1

Das von der Annahme arbeitet, dass Win32 Ereignisse teuer sind. Sie sind nicht, es gibt wenig, dass ich denken kann, das ist billiger als ein Ereignis. Ein wichtiger Hinweis, dass dies so ist, ist, dass die .NET-Designer entscheiden, dass es eine gute Idee ist, ein Win32-Ereignis zu verwenden, um MRE und ARE zu implementieren.

Die wahren Kosten für Ihren Ersatz sind die großen FUDs, die Sie erleben werden, wenn Sie ein Threading-Rennen haben und nicht wissen, was es verursacht.

Answer 2

Leider ist die korrekte Monitor-Implementierung ziemlich schwergewichtig angesichts der Win32-Synchronisationsgrundelemente. Mein anfänglicher Verdacht ist, dass "Sperren" bei der Ressourcennutzung schwerer wären als bei einem Ereignis (und wahrscheinlich auf einem Ereignis aufgebaut sind).

Answer 3

Eine Möglichkeit, die Leistung von AutoResetEvent zu optimieren, besteht darin, den Status (signalisierte/nicht signalisierte) in Ihrer eigenen Variablen zu belassen. Bevor Sie also in den Kernel fahren und das Ereignisobjekt tatsächlich verwenden, können Sie einfach den Status Ihrer Anwendung überprüfen Variable und bleiben die ganze Zeit im Benutzermodus.
Ich habe eine demonstration dieses Konzepts vor ein paar Monaten gepostet.

Answer 4

Im Allgemeinen ist jede Synchronisation langsam, daher ist es am besten, sie zu vermeiden.

Allerdings gibt es einen großen Unterschied zwischen ihrer Geschwindigkeit:

Die CPU unterstützt Interlocked Exchange ist die schnellste, während eine einfache Boolesche Flag Autoreset noch schlägt.

prüfen dies für die vollständige Codebeispiele und performance comparisons on AutoResetEvent and alternatives.