饿汉单例模式
程序还没有主动获取实例对象，该对象就产生了，也就是程序刚开始运行，这个对象就已经初始化了。
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){return &singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton singleton;
};
Singleton Singleton::singleton;//类的静态成员变量要在类外定义
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}显然饿汉模式是线程安全的，因为单例对象的初始化发生在.bss段，和栈无关，而线程的启动依赖于函数，函数需要开辟栈内存，所以是线程安全的。但是饿汉模式也有缺点，如果这个单例类的构造函数过于复杂，包含了线程和数据库等等一系列的初始化过程，需要进行大量操作，就会导致程序启动变慢。
运行结果如下： 三个对象的地址是一样的，说明是同一个对象，并且最后也只是析构了一次。
懒汉模式
实例对象直到程序中有模块获取它时，才会初始化这个对象。
#include<iostream>
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){if (singleton == nullptr){singleton = new Singleton();}return singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton* singleton;
};
Singleton* Singleton::singleton=nullptr;//类的静态成员变量要在类外定义
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}运行结果。
上面这种写法显然是线程不安全的，因为要构造一个单例，构造函数里面可能需要进行大量的操作。这段代码就会产生竞态条件，我们需要通过线程间的互斥操作来解决。
#include<iostream>
#include<memory>
#include<thread>
#include<mutex>
std::mutex mtx;
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){std::lock_guard<std::mutex>loc(mtx);if (singleton == nullptr){singleton = new Singleton();}return singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton* singleton;
};
Singleton* Singleton::singleton=nullptr;//类的静态成员变量要在类外定义
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}这种写法虽然可以解决问题，但是加锁的位置，对程序的性能损耗较大，每次要先拿到锁才去判断是否为nullptr，如果不是，这把锁就白拿了，换一下加锁的位置。
#include<iostream>
#include<memory>
#include<thread>
#include<mutex>
std::mutex mtx;
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){if (singleton == nullptr){std::lock_guard<std::mutex>loc(mtx);singleton = new Singleton();}return singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton* singleton;
};
Singleton* Singleton::singleton=nullptr;//类的静态成员变量要在类外定义
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}这次加锁位置明显可以减少程序的性能损耗，但是会出现一个问题，假如开始单例是nullptr，一个线程通过if语句，并且拿到了锁，它只是开辟了内存，并且构造了单例对象，但是构造过程没有执行完全，还没有给这个单例对象赋值， 这时候这个单例还是nullptr，另一个线程这时候也可以通过if语句了，因为单例是nullptr，但是它不能构造单例，因为没有拿到锁，这时候第一个线程给单例赋值完成后，释放了锁，第二个线程拿到锁，就又构造了一次单例。
要解决这个问题也简单，那就是双重if语句判断。
#include<iostream>
#include<memory>
#include<thread>
#include<mutex>
std::mutex mtx;
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){if (singleton == nullptr){std::lock_guard<std::mutex>loc(mtx);if (singleton == nullptr){singleton = new Singleton();}}return singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton* singleton;
};
Singleton* Singleton::singleton=nullptr;//类的静态成员变量要在类外定义
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}运行结果还是一样的。
如果我们要简化上面的写法呢？我们可以使用到函数静态局部变量的初始化机制，函数静态局部变量在初始化的时候，底层的汇编指令会自动添加上线程互斥的指令，就可以省去我们加锁的步骤了。而且只有当程序主动调用get_instance函数的时候，单例才会被初始化，也省去了我们的nullptr双重判断了。
#include<iostream>
#include<memory>
#include<thread>
#include<mutex>
std::mutex mtx;
class Singleton
{
public:~Singleton(){std::cout << "~Singleton()" << std::endl;}static Singleton* get_instance(){static Singleton singleton;return &singleton;}
private:Singleton() {};Singleton(const Singleton& othersingle) = delete;Singleton& operator=(const Singleton& othersingle) = delete;static Singleton* singleton;
};
int main()
{Singleton* s1 = Singleton::get_instance();Singleton* s2 = Singleton::get_instance();Singleton* s3 = Singleton::get_instance();std::cout << "s1:" << s1 << std::endl;std::cout << "s2:" << s2 << std::endl;std::cout << "s3:" << s3 << std::endl;
}运行效果一样。
