Реализация потокобезопасного Singleton

Решение

Анализ задачи

Singleton паттерн гарантирует, что класс имеет только один экземпляр и предоставляет глобальную точку доступа к нему. Ключевой вызов — обеспечить потокобезопасность при инициализации и ленивую загрузку.

Способ 1: Double-Checked Locking (КЛАССИЧЕСКИЙ, но опасный)

public class SingletonDoubleChecked
{
    private static SingletonDoubleChecked _instance;
    private static readonly object _lock = new object();

    private SingletonDoubleChecked() { }

    public static SingletonDoubleChecked GetInstance()
    {
        // Первая проверка (без блокировки) — быстрый путь
        if (_instance != null)
            return _instance;

        // Если null, входим в блокировку
        lock (_lock)
        {
            // Вторая проверка (с блокировкой) — гарантирует инициализацию
            if (_instance == null)
            {
                _instance = new SingletonDoubleChecked();
            }
        }

        return _instance;
    }
}

Проблема в Java: Double-checked locking в Java имеет проблему с memory visibility. Нужно volatile для переменной.

В C#: Благодаря более строгой модели памяти lock гарантирует memory barrier, так что это работает, но не элегантно.

Плюсы:

• Ленивая инициализация
• Потокобезопасность

Минусы:

• Сложный и подвержен ошибкам
• Требует понимания memory barriers
• Не очень читаемый код
• Может быть медленнее из-за дополнительных проверок

---

Способ 2: Lazy<T> (РЕКОМЕНДУЕТСЯ для современного C#)

public class SingletonLazy
{
    private static readonly Lazy<SingletonLazy> _instance = 
        new Lazy<SingletonLazy>(() => new SingletonLazy());

    private SingletonLazy() { }

    public static SingletonLazy GetInstance() => _instance.Value;
}

Как это работает:

• Lazy<T> встроенный класс .NET Framework
• Автоматически обеспечивает потокобезопасность
• Инициализирует экземпляр только при первом обращении к .Value
• Компилятор по умолчанию использует LazyThreadSafetyMode.ExecutionAndPublication

Плюсы:

• ✅ Ленивая инициализация
• ✅ Встроенная потокобезопасность
• ✅ Читаемый, элегантный код
• ✅ Нет необходимости в блокировках вручную
• ✅ Лучшая производительность
• ✅ Стандартное решение в индустрии

Минусы:

• Небольшие накладные расходы на Lazy<T> (обычно незначительные)

---

Способ 3: Static Readonly Field (САМЫЙ ПРОСТОЙ)

public class SingletonStatic
{
    public static readonly SingletonStatic Instance = new SingletonStatic();

    private SingletonStatic() { }
}

// Использование
var singleton = SingletonStatic.Instance;

Как это работает:

• CLR гарантирует, что static инициализаторы выполняются потокобезопасно
• Экземпляр создаётся ленивым образом (до первого обращения к типу)
• Нет явных блокировок

Плюсы:

• ✅ Максимально простой код
• ✅ Встроенная потокобезопасность от CLR
• ✅ Отличная производительность
• ✅ Невозможно ошибиться
• ✅ Читаемость

Минусы:

• Инициализация может быть вызвана неявно (при первом обращении к типу)
• Сложнее контролировать момент инициализации (если критично)

---

Способ 4: Nested Class / Bill Pugh Singleton (Java паттерн, в C# излишний)

public class SingletonNested
{
    private SingletonNested() { }

    private static class SingletonHolder
    {
        public static readonly SingletonNested Instance = new SingletonNested();
    }

    public static SingletonNested GetInstance() => SingletonHolder.Instance;
}

Почему в C#? Это паттерн из Java (где static инициализаторы менее предсказуемы). В C# это дублирование кода.

Плюсы:

• Ленивая инициализация
• Потокобезопасность
• Более чёткое разделение ответственности

Минусы:

• В C# это лишнее усложнение
• Используйте Lazy<T> вместо этого

---

Сравнительная таблица

---

Практический пример: Логирование (реальный use case)

// ❌ ПЛОХО — классический подход
public class Logger
{
    private static Logger _instance;
    private static readonly object _lock = new object();

    public void Log(string message) => Console.WriteLine(message);

    private Logger() { }

    public static Logger GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                    _instance = new Logger();
            }
        }
        return _instance;
    }
}

// ✅ ХОРОШО — современный подход
public class Logger
{
    private static readonly Lazy<Logger> _instance = 
        new Lazy<Logger>(() => new Logger());

    public void Log(string message) => Console.WriteLine(message);

    private Logger() { }

    public static Logger Instance => _instance.Value;
}

// Использование
Logger.Instance.Log("Hello");

---

Проблемы и подводные камни

1. Memory Barriers

// В Java — потребуется volatile!
private static volatile SingletonDoubleChecked _instance;

// В C# — lock обеспечивает память barriers, но читайте документацию
private static SingletonDoubleChecked _instance;  // Хорошо в C#

2. Reflection может нарушить Singleton

// ❌ Можно создать второй экземпляр через Reflection
var constructor = typeof(SingletonLazy).GetConstructor(
    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance,
    null, Type.EmptyTypes, null);
var instance2 = (SingletonLazy)constructor.Invoke(null);

// Если критично, используйте Enum Singleton (недостижимо через reflection)
public enum SingletonEnum
{
    Instance
}

// Использование
SingletonEnum.Instance;

3. Serialization может создать копию

// Если сериализуете Singleton, имплементируйте ISerializable
public class SingletonSerializable : ISerializable
{
    private static readonly Lazy<SingletonSerializable> _instance = 
        new Lazy<SingletonSerializable>(() => new SingletonSerializable());

    private SingletonSerializable() { }

    public static SingletonSerializable Instance => _instance.Value;

    // Гарантируем, что десериализация вернёт тот же экземпляр
    public object GetObjectData(SerializationInfo info, StreamingContext context)
    {
        throw new NotSupportedException();
    }
}

---

Когда NOT использовать Singleton

• Dependency Injection: В современных приложениях используйте DI контейнер
• Unit тестирование: Singleton затрудняет тестирование (глобальное состояние)
• Параллельные потоки: Singleton может стать узким местом

Модерный подход: DI + Scoped/Singleton в контейнере

// В ASP.NET Core
services.AddSingleton<ILogger, LoggerImplementation>();
// Контейнер сам управляет жизненным циклом

---

Итоги

Для большинства случаев:

• ✅ Используйте Lazy<T> — 95% случаев

Для максимальной простоты:

• ✅ Используйте Static Readonly Field — если момент инициализации не критичен

Для особых требований (reflection protection):

• ✅ Используйте Enum Singleton

В современных приложениях:

• ✅ Используйте Dependency Injection вместо Singleton

Никогда:

• ❌ Double-checked locking (слишком сложно, есть лучшие решения)