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