Когда я должен блокировать статический экземпляр в многопоточных синглетонах при использовании сеттера?

Question

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

class MyClass
{
    private static MyClass _instance;

    private static readonly object _padlock = new object();

    public static MyClass Instance
    {
        get
        {
            if(_instance == null)
            {
                lock(_padlock)
                {
                    if(_instance == null)
                    {
                        _instance = new MyClass();
                    }
                }
            }
            return _instance;
        }
        set => _instance = value;
    }

}

Answer 1

Это называется Двойная проверка блокировки .

Однако Двойная проверка блокировки требует, чтобы базовое поле было volatile ¹ .

Короче говоря, назначение является атомарным, но его нужно будет синхронизировать (полный забор, через блокировку) между различными ядрами / процессорами. Причина, по которой другое ядро ​​одновременно читает значение, может кэшировать устаревшее значение ¹ .

Есть несколько способов сделать код потокобезопасным:

• Избегайте двойной проверки блокировки и просто выполняйте все в операторе lock.
• Сделать поле volatile , используя ключевое слово volatile.
• Используйте класс Lazy, который гарантированно поточно-ориентированный .

_{Примечание : Полностью неохраняемый сеттер добавляет усложнение ³ ..}

Однако, в вашем случае, использование двойной проверки блокировки , вероятно, будет хорошо работать с одной проверкой и блокировкой с полем volatile, но я думаю, что вам лучше всего просто набрать lock все и будь в безопасности

public static MyClass Instance
{
    get
    {
         lock(_padlock)
         {
             if(_instance == null)
                 _instance = new MyClass();
             return _instance;
         }

    }
    set 
    {
         lock(_padlock)
         {
             _instance = value;
         }
    } 
}

_{Примечание : Да, это повлечет за собой снижение производительности}

---

Ссылка

• ¹ Замок с двойной проверкой не является поточно-ориентированным

• ² Знаменитая техника блокировки с двойной проверкой в ​​C #

• ³ Комментарий от @ user2864740

---

Дополнительные ресурсы

• Двойная проверка блокировки в .NET

• Знаменитая техника блокировки с двойной проверкой в ​​C #

• Двойная проверка блокировки

Answer 2

Мне кажется, что с блокировками или без блокировок (на сеттере) у вас всегда будет проблема синхронизации. Представьте себе эти сценарии:

1. У вас есть блокировка на установщике, но вызов получателю поступает как раз перед тем, как блокировка включена. Вызывающий получает старый экземпляр.
2. У вас есть блокировка на установщике, но вызов получателю поступает сразу после того, как блокировка включена. Вызывающая сторона ожидает освобождения блокировки, а затем получает новый экземпляр.
3. У вас нет блокировки на сеттер, и вызов поступает только за до того, как вы замените экземпляр. Вызывающий получает старый экземпляр.
4. У вас нет блокировки на сеттер, и вызов приходит только через после , когда вы заменяете экземпляр. Вызывающая сторона получает новый экземпляр.

С блокировками и без блокировок зависит, какой момент времени получатель получает.

Единственная проблема, которую я вижу, это если вы хотите установить Instance в null. Если это так, ваш текущий код не будет работать, потому что _instance может быть изменено между оператором if и его возвратом. Вы можете решить эту проблему, взяв копию ссылки:

public static MyClass Instance
{
    get
    {
        var instanceSafeRef = _instance;
        if(instanceSafeRef == null)
        {
            lock(_padlock)
            {
                if(_instance == null)
                {
                    _instance = new MyClass();
                }
                instanceSafeRef = _instance;
            }
        }
        return instanceSafeRef;
    }
    set => _instance = value;
}