1. 什么是单例

保证一个类只有一个实例的实现方法。

 

2. 应用场景

当一个类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 

对有些类来说，只有一个实例很重要，如线程池，注册表，文件系统等，虽然全局变量也可以提供全局访问点，但是不能防止你实例化多个对象

页面访问计数器

需要保持状态的工具类

需求很多，不能一一列举了

 

3. 实现方法

一个私有，两个静态

一个私有

就是私有构造函数
单例模式的思想就是一个类只有一个实例，即外部任何类都不能实例化该类，那么什么样的类外部不能实例化呢？我们知道，实例化一个类的时候，需要调用构造函数，而一般构造函数都是public的，所以能够被外部调用，所以能够在外部实例化，当将构造函数设置为private时，外部就不能调用类的构造函数了，也就不能实例化该类了，该类只能在类的内部实例化。这个思想是实现单例模式的关键。

两个静态

1.静态成员变量uniqueInstance，该成员变量就是类的唯一实例
2.静态方法GetInstance()，用来获取该类的唯一实例

前面提到了使用私有构造函数是实现单例模式的关键，那么下面的问题就是怎么在外部获取该单例呢？由于任何外部类都不能实例化该类，所以我们无法通过使用new一个类的对象来调用类里面的方法获取单例 ( 即不能通过

Singleton singleton = new Singleton();

singleton.GetInstance()

来获取单例 )，只能通过类里面的静态方法，通过类名调用静态方法( 

Singleton.GetInstance() 

)来获取单例，而静态方法只能调用静态成员，所以类的成员变量也必须是静态的。

 

4. 不同场景的适用方法
 

非线程安全

 

  1     ///
  2     /// 单例模式的实现
  3     ///
  4     public sealed class Singleton
  5     {
  6         //定义一个静态变量来保存类的实例
  7         private static Singleton _instance = null;
  8 
  9         //定义私有构造函数，使外界不能创建该类实例
 10         private Singleton()
 11         {
 12         }
 13         ///
 14         /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
 15         ///
 16         ///
 17         public static Singleton Instance()
 18         {
 19             //如果类的实例不存在则创建，否则直接返回
 20             if (_instance == null)
 21             {
 22                 _instance = new Singleton();
 23             }
 24             return _instance;
 25         }
 26     }

上面的单例模式的实现在单线程下确实是可以的，但是在多线程环境下会存在两个线程同时执行if (instance == null)并且创建两个不同的实例

 

简单线程安全

 

  1     ///
  2     /// 单例模式的实现
  3     ///
  4     public sealed class Singleton
  5     {
  6         // 定义一个静态变量来保存类的实例
  7         private static Singleton instance = null;
  8 
  9         // 定义一个标识确保线程同步
 10         private static readonly object padlock = new object();
 11 
 12         private Singleton()
 13         {
 14         }
 15 
 16         public static Singleton Instance()
 17         {
 18             // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
 19             // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
 20             // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
 21             lock (padlock)
 22             {
 23                 // 如果类的实例不存在则创建，否则直接返回
 24                 if (instance == null)
 25                 {
 26                     instance = new Singleton();
 27                 }
 28             }
 29             return instance;
 30         }
 31     }

 

上面的例子解决了多线程的问题,但是每个线程调用Instance()都会使用到锁，而调用锁的开销较大，这个实现会有一定的性能损失。

 

双重验证线程安全

 

  1     ///
  2     /// 单例模式的实现
  3     ///
  4     public sealed class Singleton
  5     {
  6         // 定义一个静态变量来保存类的实例
  7         private static Singleton instance = null;
  8 
  9         // 定义一个标识确保线程同步
 10         private static readonly object padlock = new object();
 11 
 12         private Singleton()
 13         {
 14         }
 15 
 16         public static Singleton Instance()
 17         {
 18             // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
 19             // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
 20             // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
 21             if (instance == null)
 22             {
 23                 lock (padlock)
 24                 {
 25                     // 如果类的实例不存在则创建，否则直接返回
 26                     if (instance == null)
 27                     {
 28                         instance = new Singleton();
 29                     }
 30                 }
 31             }
 32             return instance;
 33         }
 34     }

上面的例子在保证线程安全的同时提高了性能

 

静态变量实现单例

  1     ///
  2     /// 单例模式的实现
  3     ///
  4     public sealed class Singleton
  5     {
  6         //在Singleton第一次被调用时会执行instance的初始化
  7         private static readonly Singleton instance = new Singleton();
  8 
  9         private Singleton()
 10         {
 11         }
 12 
 13         public static Singleton Instance()
 14         {
 15             return instance;
 16         }
 17     }

上面的例子利用.net的特性来完成单例模式的创建，也是线程安全的

 

5. 单例模式的优点

在内存中只有一个对象，节省内存空间；

避免频繁的创建销毁对象，可以提高性能；

避免对共享资源的多重占用，简化访问；

为整个系统提供一个全局访问点。