Как работает блокировка?

Я вижу, что для использования объектов, которые не являются потокобезопасными, мы заключаем код в блокировку следующим образом:

private static readonly Object obj = new Object();

lock (obj)
{
    // thread unsafe code
}

Так что же происходит, когда несколько потоков обращаются к одному и тому же коду (предположим, что он выполняется в веб-приложении ASP.NET). Они в очереди? Если так, то как долго они будут ждать?

Какое влияние на производительность оказывает использование блокировок?

Это lockзаявление переведено C # 3.0 на следующее:

var temp = obj;

Monitor.Enter(temp);

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

В C # 4.0 это изменилось, и теперь оно генерируется следующим образом:

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

Вы можете найти больше информации о том, Monitor.Enterчто здесь . Чтобы процитировать MSDN:

Используется Enterдля получения монитора объекта, переданного в качестве параметра. Если другой поток выполнил объект Enter над объектом, но еще не выполнил соответствующий Exit, текущий поток будет блокироваться, пока другой поток не освободит объект. Разрешается, Enterчтобы один и тот же поток вызывался более одного раза без его блокировки; однако Exitперед тем, как другие потоки, ожидающие объекта, разблокируются, должно быть вызвано равное количество вызовов.

Monitor.EnterМетод будет ждать бесконечно; это не будет время ожидания.

Это проще, чем вы думаете.

Согласно Microsoft : lockключевое слово гарантирует, что один поток не входит в критический раздел кода, в то время как другой поток находится в критическом разделе. Если другой поток пытается ввести заблокированный код, он будет ждать блокировки до тех пор, пока объект не будет освобожден.

lockКлючевое слово вызывает Enterв начале блока и Exitв конце блока. lockКлючевое слово на самом деле обрабатывает Monitorкласс в конце.

Например:

private static readonly Object obj = new Object();

lock (obj)
{
    // critical section
}

В приведенном выше коде сначала поток входит в критическую секцию, а затем блокируется obj. Когда другой поток пытается войти, он также пытается заблокировать obj, который уже заблокирован первым потоком. Второму потоку придется ждать первого потока, чтобы освободить obj. Когда первый поток удаляется, другой поток блокируется objи входит в критическую секцию.

Нет, они не стоят в очереди, они спят

Оператор блокировки формы

lock (x) ... 

где x является выражением ссылочного типа, точно эквивалентно

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

Вам просто нужно знать, что они ждут друг друга, и только один поток войдет в блок блокировки, остальные будут ждать ...

Монитор полностью написан на .net, поэтому он достаточно быстрый, также смотрите класс Monitor с отражателем для более подробной информации.

Блокировки блокируют выполнение другими потоками кода, содержащегося в блоке блокировки. Потоки должны будут ждать, пока нить в блоке блокировки не завершится и блокировка не будет снята. Это оказывает негативное влияние на производительность в многопоточной среде. Если вам нужно это сделать, убедитесь, что код в блоке блокировки может обрабатываться очень быстро. Вы должны избегать дорогостоящих действий, таких как доступ к базе данных и т. Д.

Влияние на производительность зависит от способа блокировки. Вы можете найти хороший список оптимизаций здесь: http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/

По сути, вы должны пытаться блокировать как можно меньше, так как это переводит ваш код ожидания в спящий режим. Если у вас есть некоторые тяжелые вычисления или длительный код (например, загрузка файла) в блокировке, это приводит к огромной потере производительности.

Часть в операторе блокировки может быть выполнена только одним потоком, поэтому все остальные потоки будут бесконечно ждать, пока поток, удерживающий блокировку, завершится. Это может привести к так называемой тупиковой ситуации.

lockЗаявление переводятся на призывы к Enterи Exitметодам Monitor.

lockЗаявление будет ждать неопределенное время для блокировки объекта должен быть освобожден.

Блокировка на самом деле скрыта классом Monitor .