C # -Version des synchronisierten Java-Schlüsselworts?

Hat c # eine eigene Version des Java-Schlüsselworts "synchronized"?

Dh in Java kann es entweder für eine Funktion, ein Objekt oder einen Codeblock angegeben werden, wie folgt:

public synchronized void doImportantStuff() {
   // dangerous code goes here.
}

oder

public void doImportantStuff() {
   // trivial stuff

   synchronized(someLock) {
      // dangerous code goes here.
   }
}

Erstens: Die meisten Klassen müssen niemals threadsicher sein. Verwenden Sie YAGNI : Wenden Sie Thread-Sicherheit nur an, wenn Sie wissen, dass Sie es tatsächlich verwenden werden (und testen Sie es).

Für die Sachen auf Methodenebene gibt es [MethodImpl]:

[MethodImpl(MethodImplOptions.Synchronized)]
public void SomeMethod() {/* code */}

Dies kann auch für Accessoren (Eigenschaften und Ereignisse) verwendet werden:

private int i;
public int SomeProperty
{
    [MethodImpl(MethodImplOptions.Synchronized)]
    get { return i; }
    [MethodImpl(MethodImplOptions.Synchronized)]
    set { i = value; }
}

Beachten Sie, dass feldartige Ereignisse werden standardmäßig synchronisiert, während automatisch implementierte Eigenschaften sind nicht :

public int SomeProperty {get;set;} // not synchronized
public event EventHandler SomeEvent; // synchronized

Persönlich mag ich die Implementierung nicht, MethodImplda sie sperrt thisoder typeof(Foo)- was gegen Best Practice verstößt. Die bevorzugte Option ist die Verwendung eigener Schlösser:

private readonly object syncLock = new object();
public void SomeMethod() {
    lock(syncLock) { /* code */ }
}

Beachten Sie, dass bei feldähnlichen Ereignissen die Sperrimplementierung vom Compiler abhängt. In älteren Microsoft-Compilern ist es ein lock(this)/ lock(Type)- in neueren Compilern werden jedochInterlocked Updates verwendet - also threadsicher ohne die unangenehmen Teile.

Dies ermöglicht eine detailliertere Verwendung und die Verwendung von Monitor.Wait/ Monitor.Pulseetc für die Kommunikation zwischen Threads.

Ein verwandter Blogeintrag (später überarbeitet ).

static object Lock = new object();

lock (Lock) 
{
// do stuff
}

Hat c # eine eigene Version des Java-Schlüsselworts "synchronized"?

Nein. In C # geben Sie explizit lockRessourcen an, an denen Sie synchron über asynchrone Threads arbeiten möchten. locköffnet einen Block; es funktioniert nicht auf Methodenebene.

Allerdings ist der zugrunde liegende Mechanismus , da ähnliche lockArbeiten durch den Aufruf Monitor.Enter(und später Monitor.Exit) auf der Laufzeit. Java funktioniert laut Sun-Dokumentation genauso .

Beachten Sie, dass bei vollen Pfaden die Linie [MethodImpl(MethodImplOptions.Synchronized)]wie folgt aussehen sollte

[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]

Sie können lockstattdessen die Anweisung verwenden. Ich denke, dies kann nur die zweite Version ersetzen. Denken Sie auch daran, dass beide synchronizedund lockein Objekt bearbeiten müssen.