一、什么是单例模式?
顾名思义,一个类只能创建一个对象,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。
二、怎么实现?
既然只能创建一个类,那就将该类的构造函数私有化,并且将拷贝构造函数和赋值函数封锁住,在类里面提供一个获取该唯一对象的接口。(设置为静态保证只有一个对象)
三、饿汉模式:不管将来用不用,程序启动时就创建一个唯一的实例对象。
特点:简单;但可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
//饿汉模式
class Singleton
{
public:
static Singleton* Getinstance()
{
return &_instance;
}
void Print()
{
cout << "StackType::Print()" << endl;
}
private:
Singleton()
{}
//赋值运算符重载 防拷贝
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
static Singleton _instance;
};
Singleton Singleton::_instance;
int main()
{
Singleton* singleton2 = Singleton::Getinstance();
singleton2->Print();
return 0;
}
四、懒汉模式:
如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式,在使用的时候再去创建这个对象。
特点:复杂,第一次使用实例对象时,创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
#include <mutex>
class Singleton
{
public:
static Singleton* GetInstance()
{
// double check为了创建好以后不用锁的消耗
if (_spInstance == nullptr)//其他线程并发来时还要串行
{
//t1 t2
_smtx.lock();
if (_spInstance == nullptr)
{
_spInstance = new Singleton;//再main函数结束以后delete
}
_smtx.unlock();
}
return _spInstance;
}
private:
Singleton()
{
cout << "Singleton()" << endl;
}
~Singleton()
{
// close
cout << "~Singleton()" << endl;
}
//// 防拷贝 C++98
//Singleton(const Singleton&);
//Singleton& operator=(const Singleton&);
// 防拷贝 C++11
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
static Singleton* _spInstance;
static mutex _smtx;
};
mutex Singleton::_smtx;
Singleton* Singleton::_spInstance = nullptr;
五、懒汉和饿汉的比较:
1.饿汉是空间换时间:不管用不用,当类创建时就会创建类实例,然后调用的时候,就不需要再判断了,节省了运行时间。
懒汉是时间换空间:用的时候在创建,就是每次获取实例都会进行判断,看是否需要创建实例,浪费的时间。但如果没有人使 用的话,那就不会创建节约空间。
2.饿汉是线程安全的,但是懒汉如果不加锁的情况就不是线程安全的。
懒汉通过double check保证了效率和线程安全。
1>如果是这样:当线程t1、t2同时来获取该对象,t1判断对象不为空正准备创建对象但是还没有创建,这时候t2也来了判断对象 为空也去创建对象,这样就会创建多个对象有线程安全问题,因此需要加锁。
static Singleton* GetInstance()
{
if (_spInstance == nullptr)
{
_spInstance = new Singleton;
}
}
2>如果是这样:加锁后线程安全问题得到解决,但会产生效率问题。当唯一实例已经创建好,这时并发来了n个线程,那么n-1个线程都会被锁住,然后一个一个的加锁解锁判断,锁是有消耗的,其实这是不必要的,因此在外层可以再次判断一次。
static Singleton* GetInstance()
{
_smtx.lock();
if (_spInstance == nullptr)
{
_spInstance = new Singleton;
}
_smtx.unlock();
}
3>这样就是一个安全且高效的懒汉了。
static Singleton* GetInstance()
{
// double check为了创建好以后不用锁的消耗
if (_spInstance == nullptr)//其他线程并发来时还要串行
{
_smtx.lock();
if (_spInstance == nullptr)
{
_spInstance = new Singleton;
}
_smtx.unlock();
}