设计模式之单例模式的多种使用方式以及单例的优化

设计模式之单例模式的多种使用方式以及单例的优化 

具体使用案例如下：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleTest
{
    /// <summary>
    /// 测试单例
    /// </summary>
    static class TestSingleton
    {
        /// <summary>
        /// 测试单例
        /// </summary>
        public static void Test()
        {
            AA.Instance.Print();
        }
    }

    #region 单例相关
    /// <summary>
    /// 单线程
    /// </summary>
    public class SingleTon
    {
        /// <summary>
        /// 私有变量，延迟加载
        /// </summary>
        private static SingleTon instance = null;

        /// <summary>
        /// 私有构造函数，方式初始化
        /// </summary>
        private SingleTon()
        {
        }

        /// <summary>
        /// 公开实例，单例供外部使用
        /// </summary>
        public static SingleTon Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new SingleTon();
                }
                return instance;
            }
        }
    }

    /// <summary>
    /// 多线程
    /// </summary>
    public class SingleTon1
    {
        /// <summary>
        /// 私有变量,提前初始化
        /// </summary>
        private static SingleTon1 instance = new SingleTon1();

        /// <summary>
        /// 私有构造函数，方式初始化
        /// </summary>
        private SingleTon1()
        {
        }

        /// <summary>
        /// 公开实例，单例供外部使用
        /// </summary>
        public static SingleTon1 Instance => instance;
    }

    /// <summary>
    /// 多线程
    /// </summary>
    public class SingleTon2
    {
        /// <summary>
        /// 私有变量,提前初始化
        /// </summary>
        private static SingleTon2 instance = null;
        /// <summary>
        /// 锁
        /// </summary>
        private static readonly object objectlock = new object();

        /// <summary>
        /// 私有构造函数，方式初始化
        /// </summary>
        private SingleTon2()
        {
        }

        /// <summary>
        /// 公开实例，单例供外部使用
        /// </summary>
        public static SingleTon2 Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (objectlock)
                    {
                        if (instance == null)
                        {
                            instance = new SingleTon2();
                        }
                    }
                }
                return instance;
            }
        }
    }

    /// <summary>
    /// 多线程,并发字典
    /// </summary>
    public class SingleTon3
    {
        /// <summary>
        /// 并发字典
        /// </summary>
        private static readonly ConcurrentDictionary<int, SingleTon3> valuePairs = new ConcurrentDictionary<int, SingleTon3>();

        /// <summary>
        /// 私有构造函数，方式初始化
        /// </summary>
        private SingleTon3()
        {
        }

        /// <summary>
        /// 公开实例，单例供外部使用
        /// </summary>
        //public static SingleTon3 Instance => valuePairs.GetOrAdd(1, new SingleTon3());
        public static SingleTon3 Instance => valuePairs.GetOrAdd(1, k => new SingleTon3());
    }

    /// <summary>
    /// 多线程,并发字典
    /// </summary>
    public class SingleTon4
    {
        /// <summary>
        /// 并发字典
        /// </summary>
        //private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>();

        private static readonly Lazy<SingleTon4> singleTon = new Lazy<SingleTon4>(() => new SingleTon4());
        /// <summary>
        /// 私有构造函数，方式初始化
        /// </summary>
        private SingleTon4()
        {
        }

        /// <summary>
        /// 公开实例，单例供外部使用
        /// </summary>
        public static SingleTon4 Instance => singleTon.Value;
    }

    /// <summary>
    /// 多线程,原子操作
    /// </summary>
    public class SingleTon5
    {
        private int count;

        public int AddCount()
        {
            return Interlocked.Increment(ref count);
        }
    }


    /// <summary>
    /// 多线程,同步操作
    /// </summary>
    public class SingleTon6
    {
        private volatile int count;

        public int AddCount()
        {
            return count++;
        }
    }
    #endregion

    #region 单例的优化,有一点要注意，所有的单例其实都可以通过反射来创建的，但是枚举是自带单例的，无法通过反射来创建枚举实例的

    /// <summary>
    /// 单例优化以后的测试
    /// </summary>
    public class AA : SingletonStrict<AA>
    //public class AA:SingletonBase<AA>//SingletonStrict
    {
        public int MyProperty { get; set; }

        public string Name { get; set; }

        //继承SingletonStrict<AA>。不需要公开的构造器
        private AA()//继承类必须添加该私有的构造器，否则仍然可以AA aa= new AA(),这种方式就违背了单例的原则和设计初衷
        {

        }

        //继承SingletonBase<AA>。必须要公开的构造器
        //public AA()//继承类必须添加该私有的构造器，否则仍然可以AA aa= new AA(),这种方式就违背了单例的原则和设计初衷
        //{

        //}

        public void Print()
        {
            Console.WriteLine("静态内部类的线程安全的懒汉式单例");
        }

    }

    /// <summary>
    ///单例优化3
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class SingletonStrict2<T> where T : class //如果有new ()的话，则泛型T的类型必须具有公开的构造器
    {
        public static T GetSingleton()
        {
            //第一，二，三种方式
            //return Nested.Instance;
            //第四种方式
            //return lazyT.Value;
            //第五种方式
            return valuePairs.GetOrAdd(1, k => Activator.CreateInstance<T>()); //最好的是在T的具体类型中，添加私有的构造器
            //return valuePairs.GetOrAdd(1, k => new T() //约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器 
        }

        public static T Instance
        {
            //第一，二，三种方式
            //get { return lazyT.Value; }
            //第四种方式
            //get { return lazyT.Value; }
            //第五种方式
            get { return valuePairs.GetOrAdd(1, k => Activator.CreateInstance<T>()); }//最好的是在T的具体类型中，添加私有的构造器
            //get { return valuePairs.GetOrAdd(1, k => new T()); }//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器
        }

        #region 第五种方式
        private static readonly ConcurrentDictionary<int, T> valuePairs = null;
        static SingletonStrict2()
        {
            valuePairs = new ConcurrentDictionary<int, T>();
            //lazyT = new Lazy<T>(() => new T());//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器
            //lazyT = new Lazy<T>(() => Activator.CreateInstance<T>());//最好的是在T的具体类型中，添加私有的构造器
        }
        #endregion

        #region 第四种方式
        //private static readonly Lazy<T> lazyT;
        //static SingletonStrict2()
        //{
        //    lazyT = new Lazy<T>();
        //    //lazyT = new Lazy<T>(() => new T());//约束中如果有new ()的话，则泛型T的类型必须具有公开的构造器
        //    //lazyT = new Lazy<T>(() => Activator.CreateInstance<T>());//最好的是在T的具体类型中，添加私有的构造器
        //} 
        #endregion

        #region 第二种方式
        /// <summary>
        /// 静态内部类
        /// </summary>
        //private static class Nested
        //{
        //    internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //    internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //} 
        #endregion

        #region 第三种方式
        //private class Nested
        //{
        //    internal static readonly T Instance = null;
        //    static Nested()
        //    {
        //        Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //        //Instance = new T();//泛型T的类型必须具有公开的构造器
        //        //internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //        //internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //    }
        //} 
        #endregion

        #region 第一种方式
        /// <summary>
        /// 普通内部类
        /// </summary>
        //private class Nested
        //{
        //    static Nested(){}//重点在这里
        //    internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //    internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //} 
        #endregion
    }

    /// <summary>
    ///单例优化1
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class SingletonStrict<T> where T : class //如果有new ()的话，则泛型T的类型必须具有公开的构造器
    {
        public static T GetSingleton()
        {
            return Nested.Instance;
        }

        public static T Instance
        {
            get { return Nested.Instance; }
        }

        //第二种方式
        /// <summary>
        /// 静态内部类
        /// </summary>
        //private static class Nested
        //{
        //    internal static readonly T Instance = new T();
        //    internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //    internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //}

        private class Nested
        {
            internal static readonly T Instance = null;
            static Nested()
            {
                Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
                //Instance = new T();//泛型T的类型必须具有公开的构造器
                //internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
                //internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
            }
        }

        //第二种方式
        /// <summary>
        /// 普通内部类
        /// </summary>
        //private class Nested
        //{
        //    static Nested(){}//重点在这里    
        //    internal static readonly T Instance = new T();
        //}
    }

    /// <summary>
    /// 单例优化2
    ///静态内部类 
    ///这种方式采用了类装载的机制来保证初始化实例时只有一个线程
    ///静态内部类方式在外部类被加载时并不会立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成外部类的实例化。
    ///类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
    ///优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高
    /// </summary>

    public abstract class SingletonBase<T> where T : class, new()//如果有new ()的话，则泛型T的类型必须具有公开的构造器
    {
        public static T GetSingleton()
        {
            return Nested.Instance;
        }

        public static T Instance
        {
            get { return Nested.Instance; }
        }

        //第二种方式
        /// <summary>
        /// 静态内部类
        /// </summary>
        //private static class Nested
        //{
        //    internal static readonly T Instance = new T();
        //    internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //    internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //}

        //第三种方式
        private class Nested
        {
            internal static readonly T Instance = null;
            static Nested()
            {
                Instance = Activator.CreateInstance<T>();
                //Instance = new T();//泛型T的类型必须具有公开的构造器
                //Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
                //Instance = new T();//泛型T的类型必须具有公开的构造器
            }
        }

        //第二种方式
        /// <summary>
        /// 普通内部类
        /// </summary>
        //private class Nested
        //{
        //    static Nested(){}//重点在这里  
        //    internal static readonly T Instance = Activator.CreateInstance<T>();//最好的是在T的具体类型中，添加私有的构造器
        //    internal static readonly T Instance = new T();//泛型T的类型必须具有公开的构造器
        //}
    }

    //静态内部类
    //静态内部类也是作为一个外部类的静态成员而存在，创建一个类的静态内部类对象不需要依赖其外部类对象
    //在外部类加载时，静态内部类不会被立即加载，而是在外部类中被使用时才会加载，这符合懒加载的策略。
    //当我们在外部类中调用静态内部类时，会被加载，并且只会被加载一次，在加载时线程是安全的，保障了线程的安全性。

    /// <summary>
    ///外部类
    /// </summary>
    public class StaticInner
    {
        private StaticInner() { }

        /// <summary>
        /// 静态内部类
        /// </summary>
        private static class Singleton
        {
            internal static StaticInner INSTANCE = new StaticInner();
        }

        public static StaticInner GetSingleton()
        {
            return Singleton.INSTANCE;
        }

        public void Print()
        {
            Console.WriteLine("静态内部类的线程安全的懒汉式单例");
        }
    }
    //静态内部类

    //这种方式采用了类装载的机制来保证初始化实例时只有一个线程
    //静态内部类方式在外部类被加载时并不会立即变例化，而是在需要实例化时，调用getSingleton方法，才会装载 Singleton内部类，从而完成外部类的实例化。
    //类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
    //优点：避免了线程不安全，利用静态内部类的特点实现延迟加载，效率高 
    #endregion
}