Wie funktioniert das Schloss genau?

Ich sehe, dass wir für die Verwendung von Objekten, die nicht threadsicher sind, den Code mit einer Sperre wie folgt umschließen:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Was passiert also, wenn mehrere Threads auf denselben Code zugreifen (nehmen wir an, dass er in einer ASP.NET-Webanwendung ausgeführt wird)? Sind sie in der Warteschlange? Wenn ja, wie lange werden sie warten?

Welche Auswirkungen hat die Verwendung von Sperren auf die Leistung?

Die lockAnweisung wird von C # 3.0 wie folgt übersetzt:

var temp = obj;

Monitor.Enter(temp);

try
{
    // body
}
finally
{
    Monitor.Exit(temp);
}

In C # 4.0 hat sich dies geändert und wird nun wie folgt generiert:

bool lockWasTaken = false;
var temp = obj;
try
{
    Monitor.Enter(temp, ref lockWasTaken);
    // body
}
finally
{
    if (lockWasTaken)
    {
        Monitor.Exit(temp); 
    }
}

Sie können weitere Informationen über das finden , was Monitor.Entertut hier . So zitieren Sie MSDN:

Verwenden Sie Enterdiese Option , um den Monitor für das als Parameter übergebene Objekt abzurufen. Wenn ein anderer Thread ein Enter Objekt ausgeführt hat, das entsprechende jedoch noch nicht ausgeführt hat Exit, wird der aktuelle Thread blockiert, bis der andere Thread das Objekt freigibt. Es ist zulässig, dass ein Thread Entermehr als einmal aufgerufen wird, ohne dass er blockiert. Es muss jedoch eine gleiche Anzahl von ExitAufrufen aufgerufen werden, bevor andere auf das Objekt wartende Threads entsperrt werden.

Die Monitor.EnterMethode wird unendlich warten; es wird keine Zeitüberschreitung geben.

Es ist einfacher als Sie denken.

Laut Microsoft : Das lockSchlüsselwort stellt sicher, dass ein Thread keinen kritischen Codeabschnitt eingibt, während sich ein anderer Thread im kritischen Abschnitt befindet. Wenn ein anderer Thread versucht, einen gesperrten Code einzugeben, wartet er blockiert, bis das Objekt freigegeben wird.

Das lockSchlüsselwort wird Enteram Anfang des Blocks und Exitam Ende des Blocks aufgerufen. lockDas Schlüsselwort behandelt tatsächlich die MonitorKlasse am Backend.

Zum Beispiel:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

Im obigen Code betritt der Thread zuerst einen kritischen Abschnitt und wird dann gesperrt obj. Wenn ein anderer Thread versucht einzutreten, versucht er auch zu sperren obj, was bereits vom ersten Thread gesperrt ist. Der zweite Thread muss warten, bis der erste Thread freigegeben ist obj. Wenn der erste Thread verlässt, wird ein anderer Thread gesperrt objund tritt in den kritischen Bereich ein.

Nein, sie stehen nicht in der Warteschlange, sie schlafen

Eine Sperranweisung des Formulars

lock (x) ... 

wobei x ein Ausdruck eines Referenztyps ist, ist genau äquivalent zu

var temp = x;
System.Threading.Monitor.Enter(temp); 
try { ... } 
finally { System.Threading.Monitor.Exit(temp); }

Sie müssen nur wissen, dass sie aufeinander warten und nur ein Thread zum Sperren des Blocks eingeht, die anderen warten ...

Monitor ist vollständig in .net geschrieben, so dass es schnell genug ist. Weitere Informationen finden Sie in der Klasse Monitor mit Reflektor

Sperren verhindern, dass andere Threads den im Sperrblock enthaltenen Code ausführen. Die Threads müssen warten, bis der Thread im Sperrblock abgeschlossen ist und die Sperre aufgehoben wird. Dies wirkt sich negativ auf die Leistung in einer Multithread-Umgebung aus. Wenn Sie dies tun müssen, sollten Sie sicherstellen, dass der Code innerhalb des Sperrblocks sehr schnell verarbeitet werden kann. Sie sollten versuchen, teure Aktivitäten wie den Zugriff auf eine Datenbank usw. zu vermeiden.

Die Auswirkungen auf die Leistung hängen von der Art und Weise ab, wie Sie sperren. Eine gute Liste der Optimierungen finden Sie hier: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

Grundsätzlich sollten Sie versuchen, so wenig wie möglich zu sperren, da dadurch Ihr Wartecode in den Ruhezustand versetzt wird. Wenn Sie umfangreiche Berechnungen oder lang anhaltenden Code (z. B. das Hochladen von Dateien) in einer Sperre haben, führt dies zu einem enormen Leistungsverlust.

Der Teil in der lock-Anweisung kann nur von einem Thread ausgeführt werden, sodass alle anderen Threads unbegrenzt darauf warten, dass der Thread, der die Sperre hält, beendet wird. Dies kann zu einem sogenannten Deadlock führen.

Die lockAnweisung wird in Aufrufe der Enterund Exit-Methoden von übersetzt Monitor.

Die lockAnweisung wartet auf unbestimmte Zeit, bis das Sperrobjekt freigegeben wird.

Sperre ist eigentlich versteckte Monitor- Klasse.