《设计模式之禅》学习之单例模式

      1 单线程单例模式  

       何为单例模式，顾名思义，单例就是单一，单独，独一的意思。故单例模式[Singleton Pattern]我问可以定义为：保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全部变量是的一个对象被访问，但是它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证

没有其它实例可以被创建，并且它可以提供一个访问该实例的方法。简而言之，就是类里面定一个私有的构造函数，外界就不能通过new 实例化了，对于外边代码，

在类里面可以写一个公有方法，用来返回一个类的实例。

        类图描述：

   

       代码实例：

       单例模式下的类的源代码：

    class Singleton
    {
        private static Singleton instance;
        /// <summary>
        /// 私有构造函数，外部不能访问
        /// </summary>
        private Singleton()
        {
        }
        /// <summary>
        /// 获得该类的对象实例的方法，是静态的方法
        /// </summary>
        /// <returns>该类的实例对象</returns>
        public static Singleton GetInstance()
        {
            if (instance == null)
            {
                instance = new Singleton(); 
            }
            return instance;
        }
    }

    
        测试的代码：

     

  class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();

            if (s1 == s2)
            {
                Console.WriteLine("两个对象是相同的实例");
            }
            Console.ReadKey();
        }
    }

    测试结果：

       

  2 多线程单例模式

           在多线程的程序中，多线程同事访问Singleton类，調用GetInstance方法，会造成数据校验一致性遭到破坏，业务逻辑也会变得混乱。怎么修改呢，修改的方案很多，在这里仅较介绍几种常用的方案。

       方案一：静态初始化方法。“C#与公共语言运行库也提供了一种‘静态初始化’方法，这种方法不需要开发人员显示地编写线程安全代码，即可以解决多线程环境下它是不安全的问题。【MSDN】”，更改Singleton类，声明私有成员时候，直接new一个对象传给类的成员变量instance，你要的时候直接去調用，GetInstance方法，直接返回该类的实例化对象，问题解决，更改代码如下：

public sealed class Singleton//阻止派生，继承此类的子类可能会增加实例
    {
        private static readonly  Singleton instance = new Singleton();//首次引用类的任何成员时，创建实例，CLR负责变量初始化
        /// <summary>
        /// 私有构造函数，外部不能访问
        /// </summary>
        private Singleton()
        {
        }
        /// <summary>
        /// 获得该类的对象实例的方法，是静态的方法
        /// </summary>
        /// <returns>该类的实例对象</returns>
        public static Singleton GetInstance()
        {
            //if (instance == null)
            //{
            //    instance = new Singleton(); 
            //}
            return instance;
        }
    }

      方案二：给进程加锁，解决该方法。解释一下lock，"lock是确保当一个线程位于代码的临界区时，另一个现成不进入临界区。如果其他线程试图进入锁定的代码，则他将一直等待（即被阻止），只到该对象被释放。【MSDN】"，修改后的代码如下，

    

 public class Singleton
    {
        private static  Singleton instance;
        //程序运行时，创建一个静态只读的进程辅助对象
        private static readonly object syncRoot = new object();
        /// <summary>
        /// 私有构造函数，外部不能访问
        /// </summary>
        private Singleton()
        {
        }
        /// <summary>
        /// 获得该类的对象实例的方法，是静态的方法
        /// </summary>
        /// <returns>该类的实例对象</returns>
        public static Singleton GetInstance()
        {
            //在同一时刻加锁的进程的部分只有一个进程可以进入
            lock (syncRoot)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

        方法三：双重锁定，在实例未被创建的时候加锁，可以保证线程的安全。代码如下（注意区别不同之处），

  

 private static  Singleton instance;
        //程序运行时，创建一个静态只读的进程辅助对象
        private static readonly object syncRoot = new object();
        /// <summary>
        /// 私有构造函数，外部不能访问
        /// </summary>
        private Singleton()
        {
        }
        /// <summary>
        /// 获得该类的对象实例的方法，是静态的方法
        /// </summary>
        /// <returns>该类的实例对象</returns>
        public static Singleton GetInstance()
        {
            //在同一时刻加锁的进程的部分只有一个进程可以进入
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

        肯定会有人问，在外面已经判断了instance实例是否存在，为什么在lock里面，还要进行一次instance实例是否存在的判断呢 ？

        呵呵，仔细分析一下便可明白。对于instance已经存在，直接返回，没有问题。当instance为null时，并且同时有两个现成调用GetInstance方法，他们将都可以通过第一重instance == null 的判断，然后由于lock机制，这两个现成只有一个进入，另一个排队，必须在要其中的一个进入并出来之后，另一个才能进入。而此时如果没有第二重的判断，第二个现成还可以继续创建新的实例，没有达到目的，故需要第二重的判断。