设计模式学习之单件模式（Singleton）

作用：保证一个类只能有一个实例。并提供一个访问它的全局访问点。属于创建型模式。
实现要点：一.使用一个静态成员变量作为“全局”实例，这样就确保了唯一性
              二.使用静态的成员函数instance()替代new来获取该类的实例，这样就提供了全局的访问点
              三.构造函数设为private，使调用者不能用new来创建此类的实例
代码：两种方法实现单件模式，一种是Early initialization，一种是Lazy Initialization。

方法一：

// Early initialization
     class  EarlySingleton
    {
         private   static  EarlySingleton earlyInstance  =   new  EarlySingleton();
         private  EarlySingleton()
        {

        }
         public   static  EarlySingleton Instance()
        {
             return  earlyInstance;
        }
    }

 

方法二：

// Lazy Initialization
     class  LazySingleton
    {
         private   static  LazySingleton lazyInstance;
         private  LazySingleton()
        {

        }
         public   static  LazySingleton Instance()
        {
             if  (lazyInstance  ==   null )
            {
                lazyInstance  =   new  LazySingleton();
            }
             return  lazyInstance;
        }
    }

 

 深入：观察代码可以看出，方法二的静态变量只有在需要使用的时候才实例化，与方法一不管什么时候都一直存在相比，更加节省系统资源。但是方法二也不是没有问题——当使用多线程时，由于可能的线程异步，某个线程已经开始实例化lazyInstance但还未完成，而另一个线程在判断lazyInstance == null时仍然为true，从而又实例化一个，这将招致严重的错误。解决方法有三个：这三个方法是：
 1、使用 [MethodImpl(MethodImplOptions.Synchronized)] ，指定instance()方法同时只能被一个线程使用

 2、lock(myObject)，是对一个对象加互斥锁，只允许一个线程访问其后大括号中语句块，直到该语句块的代码执行完才解锁，解锁后才允许其他的线程执行其语句块。

3、使用 Mutex  类的 WaitOne 方法。

按这三个方法修改后的代码分别如下：

1.

using  System.Threading;
using  System.Runtime.CompilerServices; 
// Lazy Initialization
     class  LazySingleton
    {
         private   static  LazySingleton lazyInstance;
         private  LazySingleton()
        {

        }
        [MethodImpl(MethodImplOptions.Synchronized)]  // 方法的同步属性 
         public   static  LazySingleton Instance()
        {
             if  (lazyInstance  ==   null )
            {
                lazyInstance  =   new  LazySingleton();
            }
             return  lazyInstance;
        }
    }

2.

using  System.Threading;
// Lazy Initialization
     class  LazySingleton
    {
         private   static  LazySingleton lazyInstance;
         static   object  myObject  =   new   object (); 
         private  LazySingleton()
        {

        }
         public   static  LazySingleton Instance()
        {
             lock  (myObject)
            {
                 if  (lazyInstance  ==   null )
                {
                    lazyInstance  =   new  LazySingleton();
                }
                 return  lazyInstance;
            }
        }

    }

3.

using  System.Threading;
// Lazy Initialization
     class  LazySingleton
    {
         private   static  LazySingleton lazyInstance;
         static   object  myObject  =   new   object ();
         private   static  Mutex mut  =   new  Mutex();
         private  LazySingleton()
        {

        }
         public   static  LazySingleton Instance()
        {
            mut.WaitOne(); 
           
             if  (lazyInstance  ==   null )
            {
                lazyInstance  =   new  LazySingleton();
            }

            mut.ReleaseMutex(); 
             return  lazyInstance;
        }
    }

 

发现很多设计模式的作者都是写到此为止。其实还未结束，James.W.Cooper在他的书里指出：当唯一的实例已经存在时，最好给调用者抛出一个明确的异常信息。这个很有道理，如果单件实例已存在，而调用者不知道，我们不吭声就把这个已存在的单件实例返回给他，很有可能导致他犯更大的错误。

修改Instance()中代码：

if  (lazyInstance  ==   null )
{
   lazyInstance  =   new  LazySingleton();
}
else
{
    throw   new  Exception( " Singleton should be init just once " );
}