单例模式
直接来看代码:
1 #include <iostream> 2 3 class Singleton 4 { 5 private: 6 Singleton(){std::cout<<"Singleton()"<<std::endl;}; 7 Singleton(const Singleton&) = delete; 8 Singleton& operator=(const Singleton&)= delete; 9 static Singleton* _instance; 10 11 public: 12 static Singleton* Instance() 13 { 14 if(_instance == nullptr) 15 { 16 _instance = new Singleton(); 17 } 18 return _instance; 19 } 20 21 void print() 22 { 23 std::cout<<"print()"<<std::endl; 24 } 25 26 void destory() 27 { 28 delete _instance; 29 _instance = nullptr; 30 } 31 32 ~Singleton() 33 { 34 std::cout<<"~Singleton()"<<std::endl; 35 } 36 }; 37 Singleton* Singleton::_instance = nullptr; 38 39 int main() 40 { 41 Singleton::Instance()->print(); 42 Singleton::Instance()->destory(); 43 }
一般的单例模式Demo是没有 destory() 方法的,就导致一个问题,在程序结束之后,该单例对象没有被delete,导致内存泄露,可以通过 valgrind 来查看。
优点:采用懒汉模式;确实只能产生一个对象,可以防止 Singleton obj = *Singleton::Instance(); 这样的代码产生额外对象;由于 new 操作是线程安全的,所以在多线程环境中也可以保证只产生一个对象;在程序退出前调用 destory() 方法,可避免内存泄露,另外由于 destory() 方法必须由 Singleton::Instance() 调用,所以当该方法被调用时,可以保证 new 操作已经完成。
缺点:必须在程序结束前调用 Singleton::Instance()->destory(); 方法,显得很麻烦;
另外,也有人认为上面并不是线程安全的,需要加锁。但我不这么认为,如果你确实不放心的话,可以使用饿汉模式避免这个话题:
1 class Singleton 2 { 3 private: 4 Singleton(){std::cout<<"Singleton()"<<std::endl;}; 5 Singleton(const Singleton&) = delete; 6 Singleton& operator=(const Singleton&)= delete; 7 static Singleton* _instance; 8 9 public: 10 static Singleton* Instance() 11 { 12 return _instance; 13 } 14 15 void destory() 16 { 17 delete _instance; 18 _instance = nullptr; 19 } 20 21 ~Singleton() 22 { 23 std::cout<<"~Singleton()"<<std::endl; 24 } 25 }; 26 Singleton* Singleton::_instance = new Singleton();
静态初始化实例可以保证线程安全,因为静态实例初始化在程序开始时进入主函数之前,就由主线程以单线程方式完成了初始化。
缺点:但静态初始化的顺序是不一定的,在很多时候要注意这一点,与单纯的此议题无关,除非……两个类都使用了单例模式,且一个类在构造函数中调用了另一个类的对象,而它可能还没有被构造。
那如何解决上面的那个必须使用 destory() 方法来手动在程序结束前清理堆内存的问题呢?
1 class Singleton 2 { 3 private: 4 Singleton(){std::cout<<"Singleton()"<<std::endl;}; 5 Singleton(const Singleton&) = delete; 6 Singleton& operator=(const Singleton&)= delete; 7 8 public: 9 static Singleton& Instance() 10 { 11 static Singleton _instance; 12 return _instance; 13 } 14 15 ~Singleton() 16 { 17 std::cout<<"~Singleton()"<<std::endl; 18 } 19 };
在一个函数中使用静态变量,该静态变量在函数第一次被调用时初始化,如果另一个线程在它初始化完成之前试图调用该函数,它必须等待(仅从 c++0x 开始),所以这里是线程安全的。另外当程序结束时,也不会有内存泄露问题。
同样的,如果质疑线程安全问题,或者未使用 c++0x 编译器,也可以使用饿汉模式,不过同样的:两个类都使用了单例模式,且一个类在构造函数中调用了另一个类的对象,而它可能还没有被构造。所以,最终还是推荐上面的写法,使用 c++0x 编译器,可以解决前面提到的全部问题。