设计模式之单例模式_单例模式 csdn-优快云博客

class animal
{
private: 
    animal() {}
         static animal* a ;
         
public:
    static animal* get()
    {
        if (a == nullptr)
        {
           
            a = new animal;
        }
        return a;
    }
};
animal* animal::a = nullptr;

设置成静态可在类外访问，无需创建对象，获取对象直接通过get获取唯一对象实例（分配空间）。静态变量，在类外初始化。

三.懒汉和饿汉模式

1.懒汉模式：

懒汉模式会在需要的时候创建并返回类的实例，和上面基本创建类似，但是懒汉模式会存在线程安全问题，需要加锁。

class animal
{
private: 
    animal() {}
         static animal* a ;
         static  mutex* mut;
public:
    static animal* get()
    {
        mut->lock();
        if (a == nullptr)
        {
            a = new animal;
        }
        mut->unlock();
        return a ;
    }
};
animal* animal::a = nullptr;
mutex* animal::mut = new mutex();

1.1线程安全问题

class animal
{
private: 
    animal() {}
         static animal* a ;
         static mutex mt;
public:
    static animal* get()
    {
        if (a == nullptr)
        {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
            a = new animal;
        }
        return a;
    }
};
animal* animal::a = nullptr;

void fun()
{
    animal* q = animal::get();
    
    cout << q;
}
int main()
{
    
    for (int i = 0; i < 2; i++)
    {
        thread* th = new thread(fun);
    }
        
    
    while (1);
}

这里说一下volatile，这个关键字会声明一个可能在程序控制之外被修改的变量，也就说可能是多线程访问的变量，有些编译器可能会将多次被访问的变量存入寄存器，避免了多次的多次的读入，但是存的时候可能已被修改，但是寄存器中还是未修改，这时使用volatile声明保证了变量多线程的可见性，也就是禁止存入寄存器，都从内存中操作，但这只保证了可见性，实际访问还得用锁，保证原子性。

当我们在多线程下使用单例模式创建实例，会出现创建出多个实例的情况：

可以看到，得到的两个地址是不同的。

原因：当第一个线程想要获取并创建实例之前，另一个线程也在获取，这时实例没有创建完成，导致两个线程都认为自己是先到的，然后创建了两个实例。

解决办法：加锁，同一时刻只能有一个线程去创建。

1.2 c++11懒汉模式

c++11 特性，如果多个线程尝试初始化静态局部变量，那么只会初始化一次。

2.饿汉模式

饿汉模式，编译时创建唯一实例（分配空间），没有线程安全问题，但是浪费资源。

class animal
{
private: 
    animal() {}
         static animal* a ;
        
public:
    static animal* get()
    {  
            return a ;       
    }
};
animal* animal::a = new animal();