dudumao

活得诚实,活得正直,专注极致,追随热情,忠于自我

  :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
  114 随笔 :: 1 文章 :: 36 评论 :: 0 引用
  1. namespace Singleton  
  2. {  
  3.     public class Singleton  
  4.     {  
  5.         //定义一个私有的静态全局变量来保存该类的唯一实例   
  6.         private static Singleton singleton;  
  7.   
  8.         //定义一个只读静态对象   
  9.         //且这个对象是在程序运行时创建的   
  10.         private static readonly object syncObject = new object();  
  11.   
  12.         /// <summary>   
  13.         /// 构造函数必须是私有的   
  14.         /// 这样在外部便无法使用 new 来创建该类的实例   
  15.         /// </summary>   
  16.         private Singleton()  
  17.         {  
  18.   
  19.         }  
  20.   
  21.         /// <summary>   
  22.         /// 定义一个全局访问点   
  23.         /// 设置为静态方法   
  24.         /// 则在类的外部便无需实例化就可以调用该方法   
  25.         /// </summary>   
  26.         /// <returns></returns>   
  27.         public static Singleton GetInstance()  
  28.         {  
  29.             //这里可以保证只实例化一次   
  30.             //即在第一次调用时实例化   
  31.             //以后调用便不会再实例化   
  32.   
  33.             //第一重 singleton == null   
  34.             if (singleton == null)  
  35.             {  
  36.                 lock (syncObject)  
  37.                 {  
  38.                     //第二重 singleton == null  
  39.                     if (singleton == null)  
  40.                     {  
  41.                         singleton = new Singleton();  
  42.                     }  
  43.                 }  
  44.             }  
  45.             return singleton;  
  46.         }  
  47.     }  
  48. }  

我为什么要在 if 语句中使用两次判断 singleton == null ,

这里涉及到一个名词 Double-Check Locking ,也就是双重检查锁定,

为何要使用双重检查锁定呢?

考虑这样一种情况,就是有两个线程同时到达,即同时调用 GetInstance(),

此时由于 singleton == null ,所以很明显,两个线程都可以通过第一重的 singleton == null ,

进入第一重 if 语句后,由于存在锁机制,所以会有一个线程进入 lock 语句并进入第二重 singleton == null ,

而另外的一个线程则会在 lock 语句的外面等待。

而当第一个线程执行完 new  Singleton()语句后,便会退出锁定区域,此时,第二个线程便可以进入 lock 语句块,

此时,如果没有第二重 singleton == null 的话,那么第二个线程还是可以调用 new  Singleton()语句,

这样第二个线程也会创建一个 Singleton 实例,这样也还是违背了单例模式的初衷的,

所以这里必须要使用双重检查锁定。

细心的朋友一定会发现,如果我去掉第一重 singleton == null ,程序还是可以在多线程下完好的运行的,

考虑在没有第一重 singleton == null 的情况下,

当有两个线程同时到达,此时,由于 lock 机制的存在,第一个线程会进入 lock 语句块,并且可以顺利执行 new Singleton(),

当第一个线程退出 lock 语句块时, singleton 这个静态变量已不为 null 了,所以当第二个线程进入 lock 时,

还是会被第二重 singleton == null 挡在外面,而无法执行 new Singleton(),

所以在没有第一重 singleton == null 的情况下,也是可以实现单例模式的?那么为什么需要第一重 singleton == null 呢?

这里就涉及一个性能问题了,因为对于单例模式的话,new Singleton()只需要执行一次就 OK 了,

而如果没有第一重 singleton == null 的话,每一次有线程进入 GetInstance()时,均会执行锁定操作来实现线程同步,

这是非常耗费性能的,而如果我加上第一重 singleton == null 的话,

那么就只有在第一次,也就是 singleton ==null 成立时的情况下执行一次锁定以实现线程同步,

而以后的话,便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了,这样就可以解决由线程同步带来的性能问题了。

好,关于多线程下单例模式中的双重检查锁定的实现和目标介绍就到这里了

posted on 2012-07-26 14:10  dudumao  阅读(296)  评论(0编辑  收藏
阿里云