c++线程安全单例实现

class Singleton {
public:
    // 获取单例实例的静态方法
    static Singleton& getInstance() {
        // 局部静态变量的初始化是线程安全的
        static Singleton instance;
        return instance;
    }

    // 禁止拷贝构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例方法
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }

private:
    // 私有构造函数，防止外部实例化
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }

    // 私有析构函数，防止外部删除
    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }
};

int main() {
    // 获取单例实例并调用方法
    Singleton& singleton = Singleton::getInstance();
    singleton.doSomething();

    return 0;
}

class singleton
{
public:
    static singleton* getInstance() {
        if (Instance == nullptr)
        {
            std::lock_guard<std::mutex>lck(mtx);
            if (Instance == nullptr)
            {
                Instance = new singleton();
            }
        }
        return Instance;
    }

    void dosomething() {
        std::cout << "单例在做工作" << std::endl;
    }

    singleton (const singleton&) = delete;
    singleton& operator = (const singleton&) = delete;

private:
    static singleton* Instance;
    singleton() {};
    static std::mutex mtx;
 
};
singleton* singleton::Instance = nullptr;
std::mutex singleton::mtx;
int main()
{
    singleton::getInstance()->dosomething();

    std::cout << "Hello World!\n";
}

//单例分配的堆空间内存的delete
1.std::atexit函数，正常退出执行的函数。
class singleton
{
public:
    static singleton* getInstance() {
        std::lock_guard<std::mutex> lck(mtx);
        if (Instance == nullptr)
        {
            Instance = new singleton();
            std::atexit(destroyInstance); // 注册销毁函数
        }
        return Instance;
    }

    void dosomething() {
        std::cout << "单例在做工作" << std::endl;
    }

    singleton(const singleton&) = delete;
    singleton& operator=(const singleton&) = delete;

private:
    singleton() {}
    ~singleton() {}

    static void destroyInstance() {
        delete Instance;
        Instance = nullptr;
    }

    static singleton* Instance;
    static std::mutex mtx;
};

singleton* singleton::Instance = nullptr;
std::mutex singleton::mtx;

2.智能指针的形式，使用get()，用智能指针包围着
class singleton
{
public:
    static singleton* getInstance() {   //将这个堆上分布的内存delete掉

        if (Instance == nullptr)
        {
            std::lock_guard<std::mutex>lck(mtx);
            if (!Instance)
            {
                //Instance.reset(new singleton);成功
                Instance = std::unique_ptr<singleton>(new singleton);
                //Instance = std::make_unique<singleton>();编译报错，可能是make_unique模板实例化和私有构造函数之间的事
                //如果非要这种方式构造，可以使用friende友元的形式来定义friend std::unique_ptr<singleton> std::make_unique<singleton>();
                return Instance.get();
            }
        }
        else
            return Instance.get();
    }

    void dosomething() {
        std::cout << "单例在做工作" << std::endl;
    }

    singleton(const singleton&) = delete;
    singleton& operator = (const singleton&) = delete;

private:
    //static std::unique_ptr<singleton>Instance;
    static std::unique_ptr<singleton>Instance;
    singleton() {};
    static std::mutex mtx;

};
std::unique_ptr<singleton> singleton::Instance=nullptr;
std::mutex singleton::mtx;

/线程安全的单例第二种实现形式注意：
如果锁用于 一个对象状态 而设置用来 改变 这个对象的状态，在改变状态前必须再次判断。
比如第二种形式，锁的目的是设置一个单例对象，如果对象为空（对象状态），就创建（改变）这个对象。（创建这个对象即改变对象状态）。就需要在改变前再次判断。