C# Ist diese Methode sicher?

Question

Betrachten Sie den folgenden Code ein:

Dictionary<string, string> list = new Dictionary<string, string>(); 
object lockObj = new object(); 

public void MyMethod(string a) { 

    if (list.Contains(a)) 
     return; 

    lock (lockObj) { 
     list.Add(a,"someothervalue"); 
    } 
} 

Ich rufe MyMethod("mystring") von verschiedenen Threads gleichzeitig Unter der Annahme.

Wäre es möglich für mehr als einen Thread (wir nehmen es nur als zwei) geben Sie die if (!list.Contains(a)) Anweisung in der gleichen Zeit (mit ein paar CPU Zyklen Unterschiede), beide Threads werden als false und ein Thread ausgewertet tritt in die kritische Region ein, während eine andere außerhalb gesperrt wird, so dass der zweite Thread eintritt und "mystring" erneut zur Liste hinzufügt, nachdem der erste Thread beendet wurde, was dazu führt, dass das Wörterbuch versucht, einen doppelten Schlüssel hinzuzufügen?

Answer 1

Nein, es ist nicht threadsicher. Sie benötigen das Schloss auch um die list.Contains, da es möglich ist, dass zwischen dem if-Test und dem Hinzufügen der Daten ein Thread aus- und wieder eingeschaltet wird. Ein anderer Thread kann zwischenzeitlich Daten hinzugefügt haben.

Answer 2

Sie müssen die gesamte Aussage sperren. Es ist möglich, dass Sie Probleme auf dem .Contains Teil (die Art, wie Ihr Code ist jetzt) ​​

Answer 3

laufen Sie sollten die Liste nach dem Sperren überprüfen. z.B.

if (list.Contains(a)) 
return; 

    lock (lockObj) { 
     if (list.Contains(a)) 
     return; 
     list.Add(a); 
    } 
} 

Answer 4

private Dictionary<string, string> list = new Dictionary<string, string>(); 

public void MyMethod(string a) { 
    lock (list) { 
     if (list.Contains(a)) 
     return; 
     list.Add(a,"someothervalue"); 
    } 
} 

prüfen diese Anleitung für locking, ist es gut

Einige Richtlinien beachten

1. sperren um allgemein ein eigenes statisches Objekt zu tragen, wenn auf mehreren beschreibbaren Verriegelungs Werte
2. Sperren Sie nicht Dinge mit Bereich außerhalb der Klasse oder l ocal Methode wie lock(this), die zu Deadlocks führen könnte!
3. Sie können das geänderte Objekt sperren, wenn es das einzige Objekt ist, auf das gleichzeitig zugegriffen wird
4. Stellen Sie sicher, dass das Objekt, das Sie sperren, nicht null ist!
5. können Sie sperren nur auf Referenztypen

Answer 5

Sie können zunächst eine nicht-Sperrprüfung tun, aber wenn Sie Thread-sicher sein wollen, müssen Sie im Schloss, um die Prüfung erneut wiederholen. Auf diese Weise sperren Sie nicht, es sei denn, Sie müssen die Sicherheit des Fadens gewährleisten.

Answer 6

Sie müssen die gesamte Operation sperren (überprüfen und hinzufügen) oder mehrere Threads versuchen, den gleichen Wert hinzuzufügen.

ich die ConcurrentDictionary(TKey, TValue) Verwendung würde empfehlen, da es konzipiert ist sicher fädeln.

private readonly ConcurrentDictionary<string, string> _items 
    = new ConcurrentDictionary<string, string>(); 

public void MyMethod(string item, string value) 
{ 
    _items.AddOrUpdate(item, value, (i, v) => value); 
} 

Answer 7

Ich gehe davon aus, dass Sie ContainsKey statt Contains schreiben soll. Contains auf einem Dictionary ist explizit implementiert, so dass es nicht über den Typ zugänglich ist, den Sie deklariert haben.

Ihr Code ist nicht sicher. Der Grund dafür ist, dass nichts verhindert ContainsKey und Add zur gleichen Zeit ausgeführt werden kann. Es gibt tatsächlich einige ziemlich bemerkenswerte Fehlerszenarien, die dies einführen würde. Da ich gesehen habe, wie die Dictionary implementiert ist, kann ich sehen, dass Ihr Code eine Situation verursachen könnte, in der Datenstruktur Duplikate enthält. Und ich meine es wörtlich enthält Duplikate. Die Ausnahme wird nicht unbedingt ausgelöst. Die anderen Misserfolgszenarien werden immer seltsamer und seltsamer, aber ich werde hier nicht näher darauf eingehen.

Eine geringfügige Änderung an Ihrem Code könnte eine Variation des doppelt überprüften Sperrmusters beinhalten.

public void MyMethod(string a) 
{ 
    if (!dictionary.ContainsKey(a)) 
    { 
    lock (dictionary) 
    { 
     if (!dictionary.ContainsKey(a)) 
     { 
     dictionary.Add(a, "someothervalue"); 
     } 
    } 
    } 
} 

Dies ist natürlich nicht sicherer aus dem Grund, den ich bereits angegeben habe. Tatsächlich ist es schwierig, das doppelt überprüfte Sperrmuster in allen, außer den einfachsten Fällen (wie die kanonische Implementierung eines Singleton), zu korrigieren. Zu diesem Thema gibt es viele Variationen. Sie können es mit TryGetValue oder dem Standard-Indexer versuchen, aber letztendlich sind alle diese Variationen einfach falsch.

Also wie könnte das richtig gemacht werden, ohne ein Schloss zu nehmen? Sie könnten versuchen ConcurrentDictionary. Es hat die Methode GetOrAdd, die in diesen Szenarien wirklich nützlich ist. Ihr Code würde so aussehen.

public void MyMethod(string a) 
{ 
    // The variable 'dictionary' is a ConcurrentDictionary. 
    dictionary.GetOrAdd(a, "someothervalue"); 
} 

Das ist alles, was es ist. Die GetOrAdd Funktion überprüft, ob das Element vorhanden ist. Wenn nicht, wird es hinzugefügt. Andernfalls wird die Datenstruktur in Ruhe gelassen. Dies alles geschieht auf thread-sichere Weise. In den meisten Fällen macht das ConcurrentDictionary dies, ohne auf ein Schloss zu warten. 2

---

By the way, Ihr Variablenname ist zu widerlich. Wenn es nicht für Servys Kommentar gewesen wäre, hätte ich vielleicht die Tatsache übersehen, dass wir über eine Dictionary im Gegensatz zu einer List sprachen. In der Tat, basierend auf dem Contains Anruf dachte ich zuerst, wir sprachen über eine List.

Auf den ConcurrentDictionary Leser sind völlig frei sperren. Writer immer nehmen Sie eine Sperre (fügt hinzu und aktualisiert das ist; die Entfernung ist noch frei von Sperren). Dies beinhaltet die GetOrAdd Funktion. Der Unterschied besteht darin, dass die Datenstruktur mehrere mögliche Sperroptionen enthält, sodass in den meisten Fällen keine oder nur geringe Sperrkonflikte auftreten. Aus diesem Grund wird diese Datenstruktur als "Low Lock" oder "Concurrent" im Gegensatz zu "Lock Free" bezeichnet.