LUKIYA'S NEVERLAND

前面章节主要涉及了一些预备的知识，从这一章起，我们将真正开始单例模式的研究
Singleton
首先看一个最常见的单例模式的实现，也是很多人常用的一种方式：
Singleton 设计模式的下列实现采用了 Design Patterns: Elements of Reusable Object-Oriented Software[Gamma95]
中所描述的解决方案，但对它进行了修改，以便利用 C#中可用的语言功能，如属性：
版本1：非线程安全的实现
// Bad Code ! Do not use!
public sealed class Singleton
{
    static Singleton instance=null;
 
    Singleton()
    {
    }
 
    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}
该实现主要有两个优点：
• 由于实例是在 Instance属性方法内部创建的，因此类可以使用附加功能（例如，对子类进行实例化），即使它可能引入
不想要的依赖性。
• 直到对象要求产生一个实例才执行实例化；这种方法称为"懒实例化"。懒实例化避免了在应用程序启动时实例化不必要的
singleton。 

但是，这种实现的主要缺点是在多线程环境下它是不安全的。
如果执行过程的不同线程同时判断if(instance==null)语句，发现instance为null，那就可能会创建多个 Singleton对象实例。
解决此问题的方法有很多。
 
版本二：线程安全简洁版
public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock = new object();
 
    Singleton()
    {
    }
 
    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance==null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}
在第二个版本中，我们做到了线程安全。同时我们也实现了惰性加载机制。
这个版本的唯一不足之处是lock可能会对大量的并发访问的效率造成影响。但一般的应用中这样的效率损失可以忽略不计
如果访问的效率对我们性命攸关，那我们可以改进到第三个版本
版本三：双检锁（double-check locking）保证线程安全
// Bad Code ! Do not use!
public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock = new object();
 
    Singleton()
    {
    }
 
    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {   //@位置1   此位置可能有多个线程处于waitzhuangtai
                lock (padlock)
                {
                   //重复判断一次，即使在@位置1已经有多个线程涌入的情况下仍然能保证不会重复初始化Singleton
                    if (instance==null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}
你可以对上面的代码进行一个思考，看上去双检锁机制似乎提高了访问的效率也保证了线程安全。但其实这样的写法在很多
平台和优化编译器上是错误的。
原因在于：instance = new Singleton();这行代码在不同编译器上的行为是无法预知的。一个优化编译器可以合法地如下实现
instance = new Singleton();
1. instance = 给新的实体分配内存
2. 调用Singleton的构造函数来初始化instance的成员变量（(这里的初始化指的是初始化instance的实例成员，因为Singleton
的静态成员已经初始化过了）
现在想象一下有线程A和B在调用instance，线程A先进入，在执行到步骤1的时候被踢出了cpu。然后线程B进入，B看到的是
instance已经不是null了
（内存已经分配），于是它开始放心地使用instance，但这个是错误的，因为在这一时刻，instance的成员变量还都是缺省值，
A还没有来得及执行步骤2来完成instance的初始化。
当然编译器也可以这样实现：
1. temp = 分配内存
2. 调用temp的构造函数
3. instance = temp
如果编译器的行为是这样的话我们似乎就没有问题了，但事实却不是那么简单，因为我们无法知道某个编译器具体是怎么做的。
要解决这个问题，我们可以利用 内存墙机制(MemoryBarrier)来解决这个问题，上面的代码改写如下：
版本三改正版1
public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock = new object();
 
    Singleton()
    {
    }
 
    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                lock (padlock)
                {
                    if (instance==null)
                    {
                        Singleton newVal = new Singleton();
                        System.Threading.Thread.MemoryBarrier();
                        instance = newVal;       
                    }
                }
            }
            return instance;
        }
    }
}
版本三改正版2
public sealed class Singleton
{
    static volatile Singleton instance=null;
    static readonly object padlock = new object();
 
    Singleton()
    {
    }
 
    public static Singleton Instance
    {
        get
        {
            if (instance==null)
            {
                lock (padlock)
                {
                    if (instance==null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}
   以上谈到的一些如多线程安全、双险锁、内存墙、等概念涉及到很多编译原理和汇编的知识，由于个人能力有限，也
没法进一步加以详细阐释，大家有兴趣的话参考一下以下一些网址吧：
http://msdn.microsoft.com/msdnmag/issues/05/10/MemoryModels/default.aspx
 http://blogs.msdn.com/brada/archive/2004/05/12/130935.aspx
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
http://blog.joycode.com/demonfox/archive/2007/01/04/90894.aspx
http://www.cnblogs.com/dayouluo/archive/2005/12/25/304455.html
 
好了，到此为止，我们在第三个版本的两个改进版中同时兼顾了效率、线程安全和惰性加载。
但这两个改进版虽然从应用上没有问题，但似乎又涉及了过多的专业知识，把问题复杂化了，
让人顿生生疏之感。
 
既然如此，让我们再来看一个亲切一点的版本吧：
 
版本四：简单实现，非惰性加载
 
public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();
   private Singleton(){}
   public static Singleton Instance
   {
      get
      {
         return instance;
      }
   }
}
这种实现简单，线程安全，缺陷主要是instance不是惰性加载的。准确的说是不一定是惰性加载的，因为我们无法得知instance
会在什么时候被初始化。若对我的描述有疑虑，请参考单例模式深入研究（一）。