设计模式之单例模式的多种使用方式以及单例的优化
具体使用案例如下：
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
}