三种方式构建C#单例模式

    /// <summary>
    /// 双检锁实现单例
    /// </summary>
    public sealed class SingletonDoubleCheck
    {
        //s_lock对象是实现线程安全所需要的，定义这个对象时，我们假设创建单例对象的代价高于创建一个System.Object对象
        //并假设可能根本不需要创建单例对象，否则，更经济、更简单的做法是在一个类构造器中创建单例对象
        private static Object s_lock = new Object();

        //这个字段引用一个单例对象
        private static SingletonDoubleCheck s_value = null;

        //私有构造器阻止这个类外部的任何代码创建实例
        private SingletonDoubleCheck()
        {

        }

        //以下公共静态方法返回单例对象（如有必要就创建它）
        public static SingletonDoubleCheck GetSingleton()
        {
            //如果单例对象已经创建，则直接返回它
            if (s_value != null)
            {
                return s_value;
            }

            //在指定对象上获取排他锁
            Monitor.Enter(s_lock);

            //再次检查是否已经创建
            //解决问题：若多个线程首次（单例对象还未创建）同时进入，此时，只有一个线程执行下面的代码（因为有Monitor），
            //当该线程（第一个线程）创建完实例后，另一个线程（第二个线程）立即获得锁，也执行下面的代码，
            //此时实例已经创建完成，后面的线程应该直接返回才对，因此再判断一次实例是否已经创建。
            if (s_value == null)
            {
                //若仍未创建则创建它
                SingletonDoubleCheck singleton = new SingletonDoubleCheck();

                //将singleton给s_value
                //下面的代码保证singleton中的引用只有在构造器结束执行之后才发布到s_value中
                Volatile.Write(ref s_value, singleton);

                //注意：下面的写法是不牢靠的
                //因为编译器可能会这样做：
                //1.为SingletonDoubleCheck分配内存
                //2.将引用发布到（赋给）s_value
                //3.调用构造器
                //假设在将引用发布给s_value之后，但在调用构造器之前，若有另一个线程调用了GetSingleton，
                //此时s_value不为null，该线程会使用该对象，但该对象的构造器还没执行完成。
                //s_value = new SingletonDoubleCheck();
            }

            //释放指定对象上的排他锁
            Monitor.Exit(s_lock);

            return s_value;
        }
    }

    /// <summary>
    /// C#下简单的构造单例方法
    /// CLR已保证了对类的构造是线程安全的，书写非常简便
    /// 缺点也很明显，首次访问类的任何成员时都会调用类型构造器
    /// 所以，如果该类定义了其它静态成员，就会在访问其它任何静态成员时创建该对象
    /// </summary>
    public sealed class SingletonSimple
    {
        private static SingletonSimple s_value = new SingletonSimple();

        //私有构造器阻止这个类外部的任何代码创建实例
        private SingletonSimple()
        {

        }

        //以下公共静态方法返回单例对象（如有必要就创建它）
        public static SingletonSimple GetSingleton()
        {
            return s_value;
        }

        //或
        public static SingletonSimple SingletonInstance
        {
            get { return s_value; }
        }

        //或
        public static SingletonSimple Instance { get; } = new SingletonSimple();
    }

    /// <summary>
    /// 嵌套类实现单例
    /// 如果多个线程同时调用GetSingleton，则可能创建多个SingletonNested对象
    /// 但由于使用了Interlocked.CompareExchange，所以保证只会有一个引用被发布到s_value
    /// 没有被固定下来的对象都会被垃圾回收
    /// 该种方式不会阻塞线程
    /// </summary>
    public sealed class SingletonNested
    {
        private static SingletonNested s_value = null;

        //私有构造器阻止这个类外部的任何代码创建实例
        private SingletonNested()
        {

        }

        //以下公共静态方法返回单例对象（如有必要就创建它）
        public static SingletonNested GetSingleton()
        {
            //如果单例对象已经创建，则直接返回它
            if (s_value != null)
            {
                return s_value;
            }

            //创建一个新的单例对象，并把它固定下来（如果另一个线程还没有固定它的话）
            SingletonNested singletonNested = new SingletonNested();

            //比较两个指定的引用类型的实例 T 是否相等，如果相等，则替换第一个，并且返回s_value原始值
            //s_value与null比较，如果相等则用singletonNested替换s_value，否则不替换
            Interlocked.CompareExchange(ref s_value, singletonNested, null);

            //如果该线程竞争失败，则新建的第二个单实例对象会被垃圾回收

            return s_value;
        }
    }