Как правильно реализовать паттерн Singleton в C++ с учётом многопоточности?

Правильная реализация Singleton в современном C++

Проблема, которую вы описали, действительно актуальна. Классическая реализация с ручной проверкой указателя небезопасна в многопоточной среде. Рассмотрим лучшие практики на C++11 и новее.

Вариант 1: Магическая статика (рекомендуемый)

Начиная с C++11, стандарт гарантирует потокобезопасную инициализацию статических локальных переменных. Это самый простой и эффективный способ:

class Logger {
public:
    static Logger& getInstance() {
        static Logger instance;  // Инициализируется один раз, потокобезопасно
        return instance;
    }
    
    void log(const std::string& msg) {
        std::cout << msg << std::endl;
    }
    
    // Запрещаем копирование и присваивание
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    
private:
    Logger() {
        std::cout << "Logger created" << std::endl;
    }
    
    ~Logger() {
        std::cout << "Logger destroyed" << std::endl;
    }
};

Преимущества:

• Потокобезопасность гарантируется стандартом C++11
• Автоматическое уничтожение при завершении программы
• Минимальный оверхед — нет мьютексов и атомарных операций
• Простота и читаемость

Вариант 2: С мьютексом и double-checked locking

Если вам нужен контроль над временем жизни (например, ручное удаление), можно использовать этот подход:

#include <mutex>

class Logger {
public:
    static Logger& getInstance() {
        std::call_once(initFlag, [](){
            instance.reset(new Logger());
        });
        return *instance;
    }
    
    static void destroyInstance() {
        std::call_once(destroyFlag, [](){
            instance.reset();
        });
    }
    
private:
    Logger() {}
    ~Logger() {}
    
    static std::unique_ptr<Logger> instance;
    static std::once_flag initFlag;
    static std::once_flag destroyFlag;
};

std::unique_ptr<Logger> Logger::instance;
std::once_flag Logger::initFlag;
std::once_flag Logger::destroyFlag;

Вариант 3: Атомарный указатель (для продвинутых)

Используется, когда нужна максимальная производительность:

#include <atomic>

class Logger {
public:
    static Logger& getInstance() {
        Logger* inst = instance.load(std::memory_order_acquire);
        if (!inst) {
            std::lock_guard<std::mutex> lock(mtx);
            inst = instance.load(std::memory_order_relaxed);
            if (!inst) {
                inst = new Logger();
                instance.store(inst, std::memory_order_release);
            }
        }
        return *inst;
    }
    
private:
    Logger() {}
    
    static std::atomic<Logger*> instance;
    static std::mutex mtx;
};

std::atomic<Logger*> Logger::instance{nullptr};
std::mutex Logger::mtx;

Рекомендации

• Для 99% случаев используйте магическую статику (Вариант 1). Это современный, безопасный и производительный подход.
• Избегайте сырых указателей — используйте умные указатели (std::unique_ptr, std::shared_ptr).
• Всегда запрещайте копирование и присваивание для Singleton.
• Помните, что Singleton — это антипаттерн в некоторых контекстах. Рассмотрите внедрение зависимостей (Dependency Injection) как альтернативу.

Ваша первоначальная реализация с сырым указателем и без синхронизации — классический пример того, как НЕ надо делать. В современном C++ есть все инструменты для корректной реализации.

template<typename T>
class Singleton {
public:
    static T& getInstance() {
        static T instance;
        return instance;
    }
    
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
protected:
    Singleton() = default;
    ~Singleton() = default;
};

// Использование
class Logger : public Singleton<Logger> {
    friend class Singleton<Logger>;  // Даёт доступ к конструктору
public:
    void log(const std::string& msg) { /* ... */ }
private:
    Logger() { /* инициализация */ }
};

class Logger {
public:
    static Logger& getInstance() {
        if (testInstance) return *testInstance;
        static Logger instance;
        return instance;
    }
    
    // Только для тестов!
    static void setTestInstance(Logger* inst) {
        testInstance = inst;
    }
    
    virtual void log(const std::string& msg) = 0;
    virtual ~Logger() = default;
    
private:
    static Logger* testInstance;
};

// В тестах:
class MockLogger : public Logger {
    void log(const std::string& msg) override {
        // mock implementation
    }
};

TEST_F(MyTest, SomeTest) {
    MockLogger mock;
    Logger::setTestInstance(&mock);
    // Теперь все вызовы Logger::getInstance() вернут mock
}