Singleton 带参数初始化

Question

我想知道制作安全initialise() getInstance()最佳方法是什么例如

#include <memory>
#include <mutex>
#include <atomic>

class MySingleton {
public:
    static void initialise(const std::string& myName) {
        std::lock_guard<std::mutex> lock(MySingleton::m_initMutex);
        if (!MySingleton::m_initialised) {
             m_self = std::shared_ptr<MySingleton>(new MySingleton(myName));
             MySingleton::m_initialised = true;
        }
    }

    static std::shared_ptr<MySingleton> getInstance(){
        if ( MySingleton::m_initialised.load()) {
            return m_self;
        } else {
            return nullptr;
        }
    }

    MySingleton(const MySingleton&) = delete;
    MySingleton& operator=(const MySingleton&) = delete;
private:
    MySingleton(const std::string myName) : m_myName(myName) {}
    
    static std::shared_ptr<MySingleton> m_self;
    static std::mutex m_initMutex;
    static std::atomic<bool> m_initialised;

    std::string m_myName;
};

std::shared_ptr<MySingleton> MySingleton::m_self{nullptr};
std::atomic<bool> MySingleton::m_initialised{false};
std::mutex MySingleton::m_initMutex;

这有什么危险/不是线程安全的吗？ 有没有更清洁/更好的方法来解决这个问题？

Answer 1

根据 C++ 标准，函数体内的任何static变量始终受原子布尔值保护（以检查它是否已初始化），初始化受互斥体保护。

这使得static变量成为一个非常方便的工具，可以为实现 Singleton 概念创建最简单但线程安全的解决方案。 我在以下 5 行代码中执行此操作，并使用std::optional来传递初始值。 如果我们第一次忘记传递 init 值，Optional 的方法.value()会抛出异常。

如您所见，我制作了 Singleton function 模板，因此您可以在其中存储任何类型，还添加了第二个可选的 UniqueTag 参数，以便您可以从一种类型中创建多个单例。

提醒一下，任何模板化的 function 对于模板的每个实例化都有自己的 static 变量实例。 所以所有的单例在里面都有不同的 static 变量。

在线尝试！

#include <optional>
#include <iostream>

template <typename T, typename UnqiueTag = void>
T const & Singleton(std::optional<T> const & init = std::nullopt) {
    static T val{init.value()};
    return val;
}

int main() {
    struct First {};
    struct Second {};
    std::cout
        << Singleton<int, First>(123) << " "
        << Singleton<int, First>() << " "
        << Singleton<int, Second>(456) << " "
        << Singleton<int, Second>() << " "
        << Singleton<std::string>("Hello!") << " "
        << Singleton<std::string>() << " "
        << std::endl;
}

Output：

123 123 456 456 Hello! Hello!

Answer 2

这是一个带有初始化的最小的类似 Meyers 的 singleton。

class Singleton
{
  private:
    int data;
    Singleton(int d) : data(d) {};
    Singleton(const Singleton&) = delete;
    void operator=(const Singleton&) = delete;
  public:
    int getData() { return data; }

    static Singleton& instance(std::function<Singleton()> *init = nullptr) {
        static Singleton s{(*init)()};
        return s;
    }

    static void initialize(int d) {
        std::function<Singleton()> init = [d]() { return Singleton(d); };
        instance(&init);
    }
};

如果你在没有先调用initialize的情况下调用instance ，它会在取消引用 null 指针时崩溃（当然，如果你愿意，可以在调试模式或发布模式下随意插入断言/检查以捕获它）。

这需要C++17； 对于早期版本的语言，将delete替换为default 。