¿Cómo funciona exactamente el bloqueo?

Veo que para usar objetos que no son seguros para subprocesos envolvemos el código con un bloqueo como este:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Entonces, ¿qué sucede cuando varios subprocesos acceden al mismo código (supongamos que se ejecuta en una aplicación web ASP.NET). ¿Están en cola? Si es así, ¿cuánto tiempo esperarán?

¿Cuál es el impacto en el rendimiento debido al uso de bloqueos?

La lockdeclaración es traducida por C # 3.0 a la siguiente:

var temp = obj;

Monitor.Enter(temp);

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

En C # 4.0 esto ha cambiado y ahora se genera de la siguiente manera:

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

Puedes encontrar más información sobre lo que Monitor.Enterhace aquí . Para citar MSDN:

Use Enterpara adquirir el Monitor en el objeto pasado como parámetro. Si otro hilo ha ejecutado un Enter en el objeto pero aún no ha ejecutado el correspondiente Exit, el hilo actual se bloqueará hasta que el otro hilo libere el objeto. Es legal que el mismo hilo invoque Entermás de una vez sin bloquearlo; sin embargo, se Exitdebe invocar un número igual de llamadas antes de que otros hilos que esperan en el objeto se desbloqueen.

El Monitor.Entermétodo esperará infinitamente; No se agotará el tiempo.

Es más simple de lo que piensas.

Según Microsoft : la lockpalabra clave asegura que un hilo no entre en una sección crítica de código mientras otro hilo está en la sección crítica. Si otro hilo intenta ingresar un código bloqueado, esperará, bloqueará, hasta que se libere el objeto.

La lockpalabra clave llama Enteral comienzo del bloque y Exital final del bloque. lockLa palabra clave realmente maneja la Monitorclase en el back-end.

Por ejemplo:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

En el código anterior, primero el hilo entra en una sección crítica, y luego se bloqueará obj. Cuando otro subproceso intenta ingresar, también intentará bloquear obj, que ya está bloqueado por el primer subproceso. El segundo hilo tendrá que esperar a que se libere el primer hilo obj. Cuando sale el primer hilo, otro se bloqueará objy entrará en la sección crítica.

No, no están en cola, están durmiendo.

Una declaración de bloqueo del formulario

lock (x) ... 

donde x es una expresión de un tipo de referencia, es precisamente equivalente a

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

Solo necesita saber que se están esperando el uno al otro, y solo ingresará un hilo para bloquear el bloqueo, los otros esperarán ...

Monitor está escrito completamente en .net, por lo que es lo suficientemente rápido, también mire la clase Monitor con reflector para obtener más detalles

Los bloqueos bloquearán que otros hilos ejecuten el código contenido en el bloque de bloqueo. Los hilos tendrán que esperar hasta que el hilo dentro del bloque de bloqueo se haya completado y se libere el bloqueo. Esto tiene un impacto negativo en el rendimiento en un entorno multiproceso. Si necesita hacer esto, debe asegurarse de que el código dentro del bloque de bloqueo pueda procesarse muy rápidamente. Debe intentar evitar actividades costosas como acceder a una base de datos, etc.

El impacto en el rendimiento depende de la forma en que se bloquea. Puede encontrar una buena lista de optimizaciones aquí: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

Básicamente, debe tratar de bloquear lo menos posible, ya que pone su código de espera para dormir. Si tiene algunos cálculos pesados ​​o un código de larga duración (por ejemplo, carga de archivos) en un bloqueo, se produce una gran pérdida de rendimiento.

La parte dentro de la declaración de bloqueo solo puede ejecutarse mediante un subproceso, por lo que todos los demás subprocesos esperarán indefinidamente a que finalice el subproceso que mantiene el bloqueo. Esto puede resultar en un llamado punto muerto.

La lockdeclaración se traduce en llamadas a los métodos Entery Exitde Monitor.

La lockdeclaración esperará indefinidamente a que se libere el objeto de bloqueo.

el bloqueo está realmente oculto Clase de monitor .