Можно ли в передать строку lock?

Краткий ответ

Нет, передавать строку напрямую в оператор lock в C# — это крайне опасная и неправильная практика, хотя с точки зрения синтаксиса компилятор это допускает. Такой подход может привести к неожиданным взаимным блокировкам (deadlock), трудно отлавливаемым ошибкам и нестабильности приложения.

Почему блокировка по строке — это проблема?

1. Интернирование строк (String Interning)

В .NET строки являются неизменяемыми (immutable), и среда выполнения для оптимизации памяти использует механизм пула строк (string interning). Это означает, что литералы с одинаковым значением могут ссылаться на один и тот же объект в памяти.

string lockString = "MyLock";
// Обе переменные ссылаются на ОДИН объект в пуле интернированных строк
string anotherReference = "MyLock"; 

lock (lockString)
{
    // Другой поток может заблокировать тот же объект через другую переменную!
    lock (anotherReference)
    {
        // Возможен deadlock или неожиданное взаимное исключение
    }
}

2. Отсутствие контроля и инкапсуляции

Строки — это примитивные типы данных, которые могут использоваться в разных, несвязанных частях приложения. Блокировка по строке нарушает принцип инкапсуляции синхронизации.

// В одном модуле
lock ("GlobalCacheLock")
{
    // Работа с кэшем
}

// В совершенно другом, независимом модуле
lock ("GlobalCacheLock") // Случайно используем ту же строку!
{
    // Работа с файловой системой
}

Эти два никак не связанных участка кода будут блокировать друг друга, что приведёт к падению производительности и непредсказуемому поведению.

3. Проблемы безопасности

Если строка формируется динамически из пользовательского ввода, злоумышленник может специально создавать строки, которые приведут к DoS-атаке (Denial of Service) через взаимные блокировки.

// ОПАСНО! Пользовательский ввод может создать deadlock
string userInput = GetUserInput(); // Злоумышленник может всегда вводить "AdminLock"
lock (userInput)
{
    // Критическая секция
}

Правильная альтернатива

Для синхронизации потоков всегда следует использовать специально созданные объекты.

1. Выделенный объект для блокировки

Создавайте отдельный объект типа object с областью видимости, соответствующей нужному контексту синхронизации.

public class ThreadSafeClass
{
    // Специальный объект только для блокировки
    private readonly object _syncRoot = new object();
    
    private int _counter;
    
    public void Increment()
    {
        lock (_syncRoot)
        {
            _counter++;
        }
    }
}

2. Использование System.Threading.Monitor

Оператор lock — это синтаксический сахар для Monitor.Enter/Monitor.Exit. Можно использовать Monitor напрямую для более сложных сценариев.

private readonly object _lockObj = new object();

public void ComplexOperation()
{
    bool lockTaken = false;
    try
    {
        Monitor.Enter(_lockObj, ref lockTaken);
        // Критическая секция
    }
    finally
    {
        if (lockTaken)
            Monitor.Exit(_lockObj);
    }
}

3. Специализированные примитивы синхронизации

Для сложных сценариев используйте современные примитивы из пространства имён System.Threading:

// Для читателей-писателей
private readonly ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();

// Для семафоров
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

// Для межпроцессной синхронизации
private readonly Mutex _mutex = new Mutex(false, "GlobalMutexName");

Исключения и особые случая

Единственный сценарий, где блокировка по строке может иметь смысл — это глобальная синхронизация между процессами, но и здесь следует использовать специальные примитивы (Mutex, Semaphore с именами).

// ВМЕСТО lock("GlobalName") используйте:
using var mutex = new Mutex(false, "GlobalProcessMutexName");
try
{
    mutex.WaitOne();
    // Критическая секция между процессами
}
finally
{
    mutex.ReleaseMutex();
}

Вывод

Никогда не используйте строки в качестве объектов блокировки. Эта практика считается антипаттерном в разработке на C#. Всегда создавайте:

• Выделенные объекты (private readonly object _syncRoot)
• С правильной областью видимости
• С явной целью синхронизации

Такой подход делает код:

• Предсказуемым и понятным
• Безопасным от случайных взаимных блокировок
• Производительным (отсутствие неожиданных contention)
• Поддерживаемым (легко рефакторить и отлаживать)

Помните: lock требует ссылочного типа, но не любой ссылочный тип подходит для блокировки. Используйте объекты, созданные исключительно для этой цели.