（1）实例控制：单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

（2）灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点：

（1）开销：虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

（2）可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

（3）对象生存期：不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。。

 1 //设计一个类，成为单例
 2 class Lock  //自造轮子
 3 {
 4 public:
 5     //RAII思想
 6     Lock(mutex& mx)
 7         :_mx(mx)
 8     {
 9         _mx.lock();
10     }
11     ~Lock()
12     {
13         _mx.unlock();
14     }
15 private:
16     Lock(const Lock&);
17     Lock& operator=(const Lock&);
18 
19     mutex& _mx;
20 };
21 //懒汉模式
22 class Singleton
23 {
24 public:
25     //1.获取本身静态私有对象的静态成员函数
26     static Singleton* GetInstance()
27     {
28         if (_inst == NULL) {
29             //加锁(防死锁)-->线程安全
30             //lock_guard<mutex> lock(_mtx);
31             Lock lock(_mtx);
32 
33             Singleton* tmp = new Singleton;
34 
35             //双检查
36             MemoryBarrier();
37             _inst = tmp;
38         }
39         return _inst;
40     }
41 
42     static void DelInstance()
43     {
44         lock_guard<mutex> lock(_mtx);
45         if (_inst)
46         {
47             cout << "delete" << endl;
48             delete _inst;
49             _inst = NULL;
50 
51         }
52     }
53     struct GC
54     {
55         ~GC()
56         {
57             DelInstance();
58         }
59     };
60 
61     void Print()
62     {
63         cout << "Singleton:" << _a << endl;
64     }
65 private:
66     //2.构造函数定义为私有
67     Singleton()
68         :_a(0)
69     {}
70     ~Singleton()
71     {}
72 
73     //防拷贝
74     Singleton(const Singleton&);
75     Singleton& operator=(const Singleton&);
76 
77     int _a;
78 
79     //3.静态私有对象
80     static Singleton* _inst;
81 
82     static mutex _mtx;
83 };
84 Singleton* Singleton::_inst = NULL;
85 mutex Singleton::_mtx;
86 static Singleton::GC gc;
87 
88 void Test()
89 {
90     Singleton::GetInstance()->Print();
91     Singleton::GetInstance()->Print();
92     Singleton::GetInstance()->Print();
93     Singleton::GetInstance()->Print();
94     Singleton::GetInstance()->Print();
95 }

 1 //饿汉模式
 2 class Singleton2
 3 {
 4 public:
 5     //1.获取本身静态私有对象的静态成员函数
 6     static Singleton2 GetInstance()
 7     {
 8         assert(_inst);
 9         return *_inst;
10     }
11     
12     void Print()
13     {
14         cout << "Singleton:" << _a << endl;
15     }
16 
17 private:
18     //2.构造函数定义为私有
19     Singleton2()
20         :_a(0)
21     {}
22     
23     //防拷贝
24     Singleton2(const Singleton2&);
25     Singleton2& operator=(const Singleton2&);
26 
27     int _a;
28     //3.静态私有对象
29     static Singleton2* _inst;
30 
31 };
32     void Test()
33     {
34         Singleton::GetInstance().Print();
35         Singleton::GetInstance().Print();
36         Singleton::GetInstance().Print();
37     }