1. 什么是单例

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


2. 使用场景

页面访问计数器

需要保持状态的工具类

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


3. 实现方

非线程安全

  1     /// <summary>
  2     /// 单例模式的实现
  3     /// </summary>
  4     public sealed class Singleton
  5     {
  6         //定义一个静态变量来保存类的实例
  7         private static Singleton _instance = null;
  8 
  9         //定义私有构造函数，使外界不能创建该类实例
 10         private Singleton()
 11         {
 12         }
 13         /// <summary>
 14         /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
 15         /// </summary>
 16         /// <returns></returns>
 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     /// <summary>
  2     /// 单例模式的实现
  3     /// </summary>
  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         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     /// <summary>
  2     /// 单例模式的实现
  3     /// </summary>
  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         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     /// <summary>
  2     /// 单例模式的实现
  3     /// </summary>
  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的特性来完成单例模式的创建，也是线程安全的


4. 优点

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

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

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

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