Como o bloqueio funciona exatamente?

Vejo que, ao usar objetos que não são seguros para threads, envolvemos o código com um bloqueio como este:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Então, o que acontece quando vários threads acessam o mesmo código (vamos supor que ele esteja sendo executado em um aplicativo Web ASP.NET). Eles estão na fila? Se sim, quanto tempo eles vão esperar?

Qual é o impacto no desempenho devido ao uso de bloqueios?

A lockdeclaração é traduzida pelo C # 3.0 para o seguinte:

var temp = obj;

Monitor.Enter(temp);

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

No C # 4.0, isso foi alterado e agora é gerado da seguinte maneira:

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

Você pode encontrar mais informações sobre o que Monitor.Enterfaz aqui . Para citar o MSDN:

Use Enterpara adquirir o Monitor no objeto passado como parâmetro. Se outro segmento executou um Enter no objeto, mas ainda não executou o correspondente Exit, o segmento atual será bloqueado até que o outro segmento libere o objeto. É legal que o mesmo encadeamento invoque Entermais de uma vez sem bloqueá-lo; no entanto, um número igual de Exitchamadas deve ser chamado antes que outros threads que aguardam no objeto sejam desbloqueados.

O Monitor.Entermétodo irá esperar infinitamente; ele vai não expirar.

É mais simples do que você pensa.

De acordo com a Microsoft : A lockpalavra-chave garante que um segmento não entre em uma seção crítica do código enquanto outro segmento está na seção crítica. Se outro encadeamento tentar inserir um código bloqueado, ele aguardará, bloqueado, até que o objeto seja liberado.

A lockpalavra-chave chama Enterno início do bloco e Exitno final do bloco. lockpalavra-chave realmente lida com a Monitorclasse no back-end.

Por exemplo:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

No código acima, primeiro o thread entra em uma seção crítica e, em seguida, será bloqueado obj. Quando outro thread tenta entrar, ele também tenta bloquear obj, que já está bloqueado pelo primeiro thread. O segundo thread precisará aguardar o lançamento do primeiro thread obj. Quando o primeiro thread sair, outro será bloqueado obje entrará na seção crítica.

Não, eles não estão na fila, estão dormindo

Uma declaração de bloqueio do formulário

lock (x) ... 

onde x é uma expressão de um tipo de referência, é precisamente equivalente a

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

Você só precisa saber que eles estão esperando um pelo outro, e apenas um segmento entrará para bloquear o bloco, os outros esperarão ...

O monitor está totalmente escrito em .net, por isso é rápido o suficiente, veja também a classe Monitor com refletor para obter mais detalhes

Bloqueios impedem que outros threads executem o código contido no bloco de bloqueio. As linhas terão que esperar até que a linha dentro do bloco de bloqueio seja concluída e a trava seja liberada. Isso tem um impacto negativo no desempenho em um ambiente multithread. Se você precisar fazer isso, verifique se o código no bloco de bloqueio pode processar muito rapidamente. Você deve tentar evitar atividades caras, como acessar um banco de dados, etc.

O impacto no desempenho depende da maneira como você bloqueia. Você pode encontrar uma boa lista de otimizações aqui: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

Basicamente, você deve tentar bloquear o mínimo possível, pois coloca seu código em espera no modo de suspensão. Se você tiver alguns cálculos pesados ​​ou código duradouro (por exemplo, upload de arquivo) em um bloqueio, isso resultará em uma enorme perda de desempenho.

A parte na instrução lock pode ser executada apenas por um thread, portanto, todos os outros threads aguardarão indefinidamente que o thread que segura a trava termine. Isso pode resultar em um chamado deadlock.

A lockinstrução é traduzida para chamadas para os métodos Entere Exitde Monitor.

A lockinstrução aguardará indefinidamente o lançamento do objeto de bloqueio.

O bloqueio está realmente oculto na classe Monitor .