设计模式-1.4单例模式

单例模式：一个类只允许生成一个实例，并提供一个访问它的全局访问点。

        private static Singleton instance;

        /// <summary>
        ///构造方法私有化，不让外界new新的实例，
        /// </summary>
        private Singleton()
        { 
        }

        /// <summary>
        /// 获得实例的唯一一个全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton getInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

注意事项：

多线程时的单例：多个线程同时访问时可能会造成多个单例。

1.懒汉式单例类：在第一次被引用时才将自己实例化

方法1：lock锁

class Singleton
    {
        private static Singleton instance;
        //程序运行时创建一个静态只读的辅助对象
        private static readonly Object syncRoot = new Object();

        /// <summary>
        ///构造方法私有化，不让外界new新的实例，
        /// </summary>
        private Singleton()
        { 
        }

        /// <summary>
        /// 获得实例的唯一一个全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton getInstance()
        {
            lock (syncRoot)//为什么不直接锁instance，第一次还没生成实例就去锁定是错误的
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

方法二：双重锁定（double-check locking）。方法一中每次进来都需要上锁，程序效率降低。

    class Singleton
    {
        private static Singleton instance;
        //程序运行时创建一个静态只读的辅助对象
        private static readonly Object syncRoot = new Object();

        /// <summary>
        ///构造方法私有化，不让外界new新的实例，
        /// </summary>
        private Singleton()
        { 
        }

        /// <summary>
        /// 获得实例的唯一一个全局访问点
        /// </summary>
        /// <returns></returns>
        public static Singleton getInstance()
        {
            //实例为空的时候才去锁定
            if (instance == null)
            {
                lock (syncRoot)//为什么不直接锁instance，第一个还没生成实例就要去锁定是错误的
                {
                    if (instance == null)//为什么上面判断了instance为空，此处还要判断，此处不判断仍然可能产生多个实例
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

2.饿汉式单例类：被加载时就将自己实例化。

    //阻止派生，派生可能增加新的实例
    public sealed class Singleton
    {

        private static readonly Singleton instance = new Singleton();
        private Singleton()
        { 
        
        }
        public static Singleton getInstance()
        {
            return instance;
        }
    }