C#的5种Singleton写法

 单例模式是二十多种设计模式中最为常见且简单的模式（没有之一），也有面试时要求考察单例模式，虽然简单，但也有不少地

方能够成为考察点。下面附上5种写法，均摘自《剑指offer》。

1.单线程环境默认单例的写法

public sealed class Singleton1
    {
        private Singleton1()
        {




        }
        private static Singleton1 instance = null;
        public static Singleton1 Instance
        {
            get {
                if (instance == null)
                    instance = new Singleton1();


                return instance;
            }
        }
    }

思路：私有化构造函数，私有化一个类级别的本类实例，CTRL R+E得到get set方法，删除set方法，判实例是否为空，是则

初始化，最后返回实例。

问题：单线程下是没毛病的，多线程情况的话就会有多个线程同时访问时访问，那么判断instance==null这句代码就不稳定

了。

2.多线程版本，有效工作，但效率不高

public sealed class Singleton2
    {
        private Singleton2()
        {


        }
        private static readonly object syncObj = new object();


        private static Singleton2 instance = null;
        public static Singleton2 Instance
        {
            get
            {
                lock (syncObj)
                {
                    if (instance == null)
                        instance = new Singleton2();
                }
                return instance;
            }
        }
    }

思路：与上例机会相似，为了防止多线程同时访问，所以加锁判断唯一访问者，即来一个类级别只读的object对象（直接实例

化），在判断instance==null之前，加锁object对象。其他没变化。

问题：该访问的弱点在于加锁的那句代码相当伤性能，如果早已把单例做了出来，就没必要每次都锁。

3.多线程优化版本

public sealed class Singleton3
    {
        private Singleton3()
        {


        }
        private static object syncObj = new object();


        private static Singleton3 instance = null;
        public static Singleton3 Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (syncObj)
                    {
                        if (instance == null)
                            instance = new Singleton3();
                    }
                }
                return instance;
            }
        }
    }

思路：在上例的基础上，优化了对已成单例的对象减少了加锁的性能损失。

问题：到这一步，其实已经解决了单例模式所要求的功能和性能实现，但还有更好的解法。

4.静态构造函数实现单例

 public sealed class Singleton4
    {
        private Singleton4()
        {


        }
        private static Singleton4 instance = new Singleton4();
        public static Singleton4 Instance
        {
            get
            {
                return instance;
            }
        }
    }

思路：C#是在调用静态构造函数时初始化静态变量，.NET运行时能够确保只调用一次静态构造函数，这样就能保证只初始化一次

instance。

问题：由于C#中调用静态构造函数是不受控制的，而是.NET运行时发现第一次使用一个类型的时候自动机构调用该类型的时候

自动调用该类型的静态构造函数。所以，使用这种方式，可能会过早创建实例，占内存。

5.实例时间可控的单例版本，算是对上例的改良，但意义不那么大

public sealed class Singleton5
    {
        private Singleton5()
        {


        }
        public static Singleton5 Instance
        {
            get
            {
                return Nested.instance;
            }
        }
        class Nested
        {
            static Nested()
            {


            }
            internal static readonly Singleton5 instance = new Singleton5();
        }
    }

思路：在目标类中私有构造函数，在该类里面在搞一个类（类中类），类中类搞个静态构造函数，并加一句

internal static readonly Singleton5 instance=new Singleton5()；

其实上例核心也是这句，即静态成员在静态函数调用下创建，之所以要搞一个类中类，是为了要用的时候才实例出来，

避免了上例创建了大半天没用却占内存的尴尬。

问题：罕见写法，属骚操作，个人还是喜欢第4种方法的简单易用。