设计模式C++单例模式

设计模式C++单例模式

参考视频:【设计模式（完整版）】1.5单例_哔哩哔哩_bilibili

分类:(对象)创建型

单例(Singleton):声明了一个名为getInstance的静态方法来返回其所属类的一个相同实例.单例的构造函数必须对客户端(Client)代码隐藏.调用getInstance方法必须是获取单例对象的唯一方式.

注:多线程环境下需要进行特殊处理

单例模式对于单线程比较简单,在多线程时才会复杂一些

问题:对于一些类来说,只有一个实例是很重要的.例如数据库或其共享资源的访问权限.并且这个实例需要易于被访问.

解决方案:保证一个类只有一个实例,并提供一个访问它的全局访问点.

此次优化过程为单线程优化为多线程方法

单线程下代码:

#include <iostream>
#include <thread>
#include <mutex>
​
class Singleton
{
private:
    Singleton(const std::string value) :m_value(value)
    {
​
    }
    ~Singleton() {}
    std::string m_value;
public:
    //不允许从外拷贝,只能通过getInstance()来获得Singleton对象
    Singleton(Singleton& other) = delete;
    Singleton(const Singleton& other) = delete;
    void operator=(const Singleton&) = delete;
    std::string value() const
    {
        return m_value;
    }
​
​
    static Singleton* getInstance(const std::string& value);
private:
    static Singleton* m_instance;
};
Singleton* Singleton::m_instance = nullptr;
Singleton* Singleton::getInstance(const std::string& value)
{
    if (m_instance == nullptr)
    {
        m_instance = new Singleton(value);
    }
    return m_instance;
}
​
void Cat()
{
    Singleton* singleton = Singleton::getInstance("Cat");
    std::cout<<singleton->value()<<std::endl;
    
}
​
void Dog()
​
{
    Singleton* singleton = Singleton::getInstance("Dog");
    std::cout << singleton->value() << std::endl;
}
​
int main()
{
    //单线程
    Cat();
    Dog();
    //多线程
    //多线程这样做时,可能会出现Cat,Dog两种情况,但是我们只想要一个实例.
    std::thread t1(Cat);
    std::thread t2(Dog);
​
    t1.join();
    t2.join();
}

在多线程下运行上面代码,有时候输出会出现cat,cat|cat,dog|dog,dog.但是我们只要一个实例,也就是说cat,dog这种事不允许出现的.

解决方法1:线程同步(详细原理见操作系统线程同步章节)

#include <iostream>
#include <thread>
#include <mutex>
​
class Singleton
{
private:
    Singleton(const std::string value) :m_value(value)
    {
​
    }
    ~Singleton() {}
    std::string m_value;
public:
    //不允许从外拷贝,只能通过getInstance()来获得Singleton对象
    Singleton(Singleton& other) = delete;
    Singleton(const Singleton& other) = delete;
    void operator=(const Singleton&) = delete;
    std::string value() const
    {
        return m_value;
    }
​
​
    static Singleton* getInstance(const std::string& value);
private:
    static Singleton* m_instance;
    static std::mutex m_mutex;
};
std::mutex Singleton::m_mutex;
Singleton* Singleton::m_instance = nullptr;
Singleton* Singleton::getInstance(const std::string& value)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_instance == nullptr)
    {
        m_instance = new Singleton(value);
    }
    return m_instance;
}
​
void Cat()
{
    Singleton* singleton = Singleton::getInstance("Cat");
    std::cout<<singleton->value()<<std::endl;
    
}
​
void Dog()
​
{
    Singleton* singleton = Singleton::getInstance("Dog");
    std::cout << singleton->value() << std::endl;
}
​
int main()
{
    //单线程
    Cat();
    Dog();
    //多线程
    //多线程这样做时,可能会出现Cat,Dog两种情况,但是我们只想要一个实例.
    //解决方法:28行和34行
    std::thread t1(Cat);
    std::thread t2(Dog);
​
    t1.join();
    t2.join();
}

我们在创建实例前加一把锁,有人之后就锁上,这样就能实现只生成一个实例对象.

但是又有缺点,因为每次创建对象都会考虑锁,影响性能,如何才能不影响性能的同时只产生一个实例呢?

所以这里引出解决方法2

解决方法2:利用C++11新特性

#include <iostream>
#include <thread>
#include <mutex>
​
class Singleton
{
private:
    Singleton(const std::string value) :m_value(value)
    {
​
    }
    ~Singleton() {}
    std::string m_value;
public:
    //不允许从外拷贝,只能通过getInstance()来获得Singleton对象
    Singleton(Singleton& other) = delete;
    Singleton(const Singleton& other) = delete;
    void operator=(const Singleton&) = delete;
    std::string value() const
    {
        return m_value;
    }
​
​
    static Singleton* getInstance(const std::string& value);
private:
    static Singleton* m_instance;
    static std::mutex m_mutex;
};
std::mutex Singleton::m_mutex;
Singleton* Singleton::m_instance = nullptr;
Singleton* Singleton::getInstance(const std::string& value)
{
    //std::lock_guard<std::mutex> lock(m_mutex);
    //if (m_instance == nullptr)
    //{
    //  m_instance = new Singleton(value);
    //}
    
    //C++11特性,当一个线程初始化一个变量的时候,其他线程会等待
    static Singleton* instance = new Singleton(value);
    return instance;
}
​
void Cat()
{
    Singleton* singleton = Singleton::getInstance("Cat");
    std::cout<<singleton->value()<<std::endl;
    
}
​
void Dog()
​
{
    Singleton* singleton = Singleton::getInstance("Dog");
    std::cout << singleton->value() << std::endl;
}
​
int main()
{
    //单线程
    Cat();
    Dog();
    //多线程
    //多线程这样做时,可能会出现Cat,Dog两种情况,但是我们只想要一个实例.
    //我们只要一个实例
    //解决方法:28行和34行
    std::thread t1(Cat);
    std::thread t2(Dog);
​
    t1.join();
    t2.join();
}

##