Come funziona esattamente il blocco?

Vedo che per l'utilizzo di oggetti che non sono thread-safe, avvolgiamo il codice con un lucchetto come questo:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Quindi cosa succede quando più thread accedono allo stesso codice (supponiamo che sia in esecuzione in un'applicazione web ASP.NET). Sono in coda? In tal caso, quanto tempo aspetteranno?

Qual è l'impatto sulle prestazioni a causa dell'utilizzo dei blocchi?

La lockdichiarazione è tradotta da C # 3.0 nel seguente:

var temp = obj;

Monitor.Enter(temp);

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

In C # 4.0 questo è cambiato e ora viene generato come segue:

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

Puoi trovare maggiori informazioni su cosa Monitor.Enterfa qui . Per citare MSDN:

Utilizzare Enterper acquisire il monitor sull'oggetto passato come parametro. Se un altro thread ha eseguito un Enter oggetto sull'oggetto ma non ha ancora eseguito il corrispondente Exit, il thread corrente si bloccherà fino a quando l'altro thread non rilascia l'oggetto. È legale che lo stesso thread invochi Enterpiù di una volta senza bloccarlo; tuttavia, è Exitnecessario richiamare un numero uguale di chiamate prima che altri thread in attesa sull'oggetto si sblocchino.

Il Monitor.Entermetodo attenderà all'infinito; essa non timeout.

È più semplice di quanto pensi.

Secondo Microsoft : la lockparola chiave garantisce che un thread non inserisca una sezione critica del codice mentre un altro thread si trova nella sezione critica. Se un altro thread tenta di inserire un codice bloccato, attenderà, bloccherà, fino al rilascio dell'oggetto.

La lockparola chiave chiama Enterall'inizio del blocco e Exitalla fine del blocco. lockla parola chiave gestisce effettivamente la Monitorclasse nel back-end.

Per esempio:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

Nel codice sopra, prima il thread entra in una sezione critica e poi si bloccherà obj. Quando un altro thread tenta di entrare, tenterà anche di bloccare obj, che è già bloccato dal primo thread. Il secondo thread dovrà attendere il rilascio del primo thread obj. Quando il primo thread lascia, quindi un altro thread si bloccherà obje entrerà nella sezione critica.

No, non sono in coda, stanno dormendo

Una dichiarazione di blocco del modulo

lock (x) ... 

dove x è un'espressione di un tipo di riferimento, è esattamente equivalente a

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

Devi solo sapere che si stanno aspettando l'un l'altro, e solo un thread entrerà per bloccare il blocco, gli altri aspetteranno ...

Il monitor è completamente scritto in .net, quindi è abbastanza veloce, guarda anche il monitor di classe con riflettore per maggiori dettagli

I blocchi impediranno ad altri thread di eseguire il codice contenuto nel blocco. I thread dovranno attendere il completamento del thread all'interno del blocco di blocco e il rilascio del blocco. Ciò ha un impatto negativo sulle prestazioni in un ambiente multithread. Se è necessario, è necessario assicurarsi che il codice all'interno del blocco di blocco sia in grado di elaborare molto rapidamente. Dovresti cercare di evitare attività costose come l'accesso a un database ecc.

L'impatto sulle prestazioni dipende dal modo in cui si blocca. Puoi trovare un buon elenco di ottimizzazioni qui: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

Fondamentalmente dovresti provare a bloccare il meno possibile, poiché mette in pausa il tuo codice di attesa. Se hai dei calcoli pesanti o un codice di lunga durata (ad es. Caricamento di file) in un blocco, si verifica una perdita di prestazioni enorme.

La parte all'interno dell'istruzione lock può essere eseguita solo da un thread, quindi tutti gli altri thread aspetteranno indefinitamente il thread che tiene il blocco per terminare. Ciò può comportare un cosiddetto deadlock.

La lockdichiarazione è tradotta in chiamate ai metodi Entere Exitdi Monitor.

L' lockistruzione attenderà indefinitamente il rilascio dell'oggetto di blocco.

il blocco è in realtà nascosto Classe monitor .