单例模式（创建型）

单例模式

　　确保一个类只有一个提供访问的全局入口，解决的是实体对象个数的问题，而其他的建造者模式都是解决new所带来的耦合关系问题。

　　要点：1、类只有一个实例

　　　　　2、全局只有一个访问入口

 public class Singleton
    {
        /// <summary>
        /// 定义静态变量保存唯一实例对象
        /// </summary>
        private static Singleton uniqueInstance;

        /// <summary>
        /// 定义一个私有的构造函数，使外界无法new一个新对象
        /// </summary>
        private Singleton()
        {
        }
        /// <summary>
        /// 定义一个全局可访问的方法，初始化对象提供访问，也可以定义公有属性来提供全局访问 
        /// </summary>
        /// <returns></returns>
        public static Singleton GetInstance()
        {
            if (uniqueInstance == null)
            {
                uniqueInstance = new Singleton();
            }
            return uniqueInstance;
        }
}

　　通过定义 private Singleton  私有构造函数，限制外部无法new一个实例出来，所有创建行为只能在内部进行

 　　

通过以上方式很轻松实现单例，但是在多线程的情况下会得到多个Singleton实例，所以需要改造一下

  public class Singleton
    {
        // 定义静态变量保存唯一实例对象
        private static  volatile Singleton uniqueInstance;

        // 定义一个标记确定配合lock线程的同步状态
        private static readonly object locker = new object();

        //定义一个私有的构造函数，使外界无法new一个新对象
        private Singleton()
        {
        }

        /// <summary>
        /// 定义多线程的情况下，提供唯一的全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton GetInstance()
        {
                       if (uniqueInstance == null)
            {
            // 当第一个线程运行到这里时，先判断实例是否存在，此时还会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，走到lock时会检查锁状态，处在加锁状态时，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            // 双重锁定只需要一句判断就可以了
                lock (locker)
                {
                    // 如果类的实例不存在则创建，否则直接返回
                    if (uniqueInstance == null)
                    {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }    

     volatile修饰：编译器在编译代码的时候会对代码的顺序进行微调，用volatile修饰保证了严格意义的顺序。一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。