背景：
有一些对象其实我们只需要一个，比方说：线程池（threadpool）、缓存（cache）、对话框、处理偏好设置和注册表（registry）的对象、日志对象，充当打印机、显卡等设备的驱动程序的对象。事实上，这类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生，例如：程序的行为异常、资源使用过量，或者是不一致的结果。因此，我们设计这种类时必须确保只有一个实例，单件模式应运而生。

单件模式的意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

结构：

如何实现：

其实我们只需要把构造函数私有化，把new对象的过程进行控制就行了，具体代码如下：

 1public class Singleton
 2    {
 3        private static Singleton uniqueInstance; // 用一个静态变量来记录Singleton类的唯一实例
 4
 5        private Singleton()   // 构造器必须私有
 6        {
 7        }
 8
 9        public static Singleton Instance
10        {
11            get
12            {
13                if (null == uniqueInstance) // 如果uniqueInstance为空，说明对象没有被创建
14                {
15                    uniqueInstance = new Singleton();
16                }
17                return uniqueInstance;
18            }
19        }
20    }
21

但是上面的代码存在一个问题。当使用多线程时，产生的对象可能不只一个，分析见下图：

如何解决这个问题：

a）、使用加锁机制，具体代码如下：

 1public class Singleton

 2    {

 3        private static Singleton uniqueInstance; // 用一个静态变量来记录Singleton类的唯一实例

 4        private static Object obj = new object();

 5        

 6        private Singleton()   // 构造器必须私有

 7        {

 8        }

 9

10        public static Singleton Instance

11        {

12            get

13            {

14                lock (obj)                      // 使用加锁，避免两个线程同时进入

15                {

16                    if (null == uniqueInstance) // 如果uniqueInstance为空，说明对象没有被创建

17                    {

18                        uniqueInstance = new Singleton();

19                    }

20                    return uniqueInstance;

21                }

22            }

23        }

24    }

25

b）、使用“急切”创建实例，不用延迟加载。具体代码如下：

 1public class Singleton
 2    {
 3        static Singleton uniqueInstance = new Singleton();  // 用一个静态变量来记录Singleton类的唯一实例
 4
 5        private Singleton()   // 构造器必须私有
 6        {
 7        }
 8
 9        public static Singleton Instance
10        {
11            get
12            {
13                return uniqueInstance;
14            }
15        }
16    }
17

c）、使用“双检锁”机制。具体代码如下：

 1public class Singleton
 2    {
 3        static Singleton uniqueInstance = null;  // 用一个静态变量来记录Singleton类的唯一实例
 4        private static Object obj = new object();
 5
 6        private Singleton()   // 构造器必须私有
 7        {
 8        }
 9
10        public static Singleton Instance
11        {
12            get
13            {
14                if (null == uniqueInstance)         // 先判断uniqueInstance是否为空，如果为空，再进行加锁 
15                {
16                    lock (obj)                      // 使用加锁，避免两个线程同时进入
17                    {
18                        if (null == uniqueInstance) // 如果uniqueInstance为空，说明对象没有被创建
19                        {
20                            uniqueInstance = new Singleton();
21                        }                        
22                    }
23                }
24                return uniqueInstance;
25            }
26        }
27    }
28

对上面三种方法的评价：

1）、a方法采用了加锁机制，每次实例化都必须加锁，而加锁耗费的系统资源比较多，因此执行效率比较低，不推荐使用。

2）、b方法书写比较简单，但没有采用延迟加载，所以可能浪费部分资源。当使用频率高且运行时负担不重时推荐使用。

3）、c方法解决了多线程问题，并且只在第一次创建对象时加锁，执行效率比a方法高，推荐使用。

在什么情形下使用单例模式：

使用Singleton模式有一个必要条件：在一个系统要求一个类只有一个实例时才应当使用单例模式。反过来，如果一个类可以有几个实例共存，就不要使用单例模式。

注意：

a）、不要使用单例模式存取全局变量。这违背了单例模式的用意，最好放到对应类的静态成员中。

b）、不要将数据库连接做成单例，因为一个系统可能会与数据库有多个连接，并且在有连接池的情况下，应当尽可能及时释放连接。Singleton模式由于使用静态成员存储类实例，所以可能会造成资源无法及时释放，带来问题。

参考文献：

《Head.First设计模式》
  吕震宇  设计模式系列