实现线程安全单例模式的四种方式

双层验证下的线程安全

//双层验证下的线程安全
    public sealed class Singleton2
    {
        private static Singleton2 instance = null;
        private static readonly object padlock = new object();

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

                    }
                }

                return instance;
            }
        }
    }

饿汉模式

//饿汉模式
    /*
     * 利用静态类预初始化的特性
     */
    public sealed class Singleton3
    {
        private static readonly Singleton3 instance = new Singleton3();

        static Singleton3()
        {
            Console.WriteLine("这里是饿汉模式静态构造方法");
        }
        private Singleton3() {
            Console.WriteLine("这里是饿汉模式私有构造方法");
        }

        public static Singleton3 Instance
        {
            get
            {
                Console.WriteLine("这里是饿汉模式");
                return instance;
            }
        }
    }

懒汉模式

/* 懒汉模式 
     * 使用嵌套类实现单例模式，使用的时候初始化嵌套类
     */
    public sealed class Singleton
    {
        private Singleton()
        {
        }

        public static Singleton Instance { get { return Nested.instance; } }

        private class Nested
        {
            // Explicit static constructor to tell C# compiler
            // not to mark type as beforefieldinit
            static Nested()
            {
            }

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

.net 4 Lazy 泛型实现的懒汉模式

/*.net 4 Lazy 泛型*/
    public sealed class Singleton4
    {
        private static readonly Lazy<Singleton4> lazy =
            new Lazy<Singleton4>(() => new Singleton4());

        public static Singleton4 Instance { get { return lazy.Value; } }

        private Singleton4()
        {
        }

        public void getValue()
        {
            Console.WriteLine("Inside lazy mode getValue");
        }
    }