c#设计模式之单例模式
c#设计模式之单例模式
场景描述
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源
单例模式无论是在实际开发中还是在软件应用中比较常见，比如，windows系统的任务管理器、IIS的HttpApplication、实际项目中的日志组件等等
实现方式
单例模式为了实现一个实例，那么只有不把实例创建暴露出去，只通过类本身来创建实例，为了实现效果，需要定义一个私有构造函数
单例模式实现方式有：饿汉式、懒汉式、双重验证式、静态内部类、延迟加载（Lazy）
下面分别对每一种实现方式做一个简单的实例，以及其优缺点
饿汉式
/// <summary> /// 创建一个 Singleton 类（饿汉式） /// 这种方式比较常用，但容易产生垃圾对象。 ///优点：没有加锁，执行效率会提高。 ///缺点：类加载时就初始化，浪费内存。 ///它基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化， ///虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， ///但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。 /// </summary> public class SingleObject { //创建 SingleObject 的一个对象 private static SingleObject instance = new SingleObject(); //让构造函数为 private，这样该类就不会被实例化 private SingleObject() { Console.WriteLine("我被创建了.饿汉式"); } //获取唯一可用的对象 public static SingleObject GetInstance() { return instance; } public void ShowMessage() { Console.WriteLine("Hello World.饿汉式"); } }
懒汉式
/// <summary> /// 创建一个 Singleton 类（懒汉式） /// 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。 /// 优点：第一次调用才初始化，避免内存浪费。 /// 缺点：懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象。 /// </summary> public class SingleObject1 { //创建 SingleObject 的一个对象 private static SingleObject1 instance; //让构造函数为 private，这样该类就不会被实例化 private SingleObject1() { } //获取唯一可用的对象 public static SingleObject1 GetInstance() { if (instance == null) { instance = new SingleObject1(); Console.WriteLine("我被创建了.懒汉式"); } return instance; } public void ShowMessage() { Console.WriteLine("Hello World.懒汉式"); } }
双重验证式
/// <summary> /// 创建一个 Singleton 类（双重验证） /// 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。 /// 优点：第一次调用才初始化，避免内存浪费，线程安全。 /// 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。 /// </summary> public class SingleObject2 { //创建 SingleObject 的一个对象 private static SingleObject2 instance; // 定义一个标识确保线程同步 private static readonly object locker = new object(); //让构造函数为 private，这样该类就不会被实例化 private SingleObject2() { } //获取唯一可用的对象 public static SingleObject2 GetInstance() { //// 如果为空，那么就加锁，创建实例 if (instance == null) { lock (locker) { //// 枷锁成功后，在做一次非空判断，避免在加锁期间以创建了实例而导致重复创建 if (instance == null) { instance = new SingleObject2(); Console.WriteLine("我被创建了.双重验证"); } } } return instance; } public void ShowMessage() { Console.WriteLine("Hello World.双重验证"); } }
静态内部类
/// <summary> /// 创建一个 Singleton 类(静态内部类) /// 这种方式不用加锁，在效率上和内存使用上都比较优秀 /// 克服了饿汉模式的不足饿汉模式执行效率高，由于在类加载的时候初始化导致内存浪费 /// </summary> public class SingletonStatic { /// <summary> /// 内部类 /// </summary> public class SingletonStaticInner { /// <summary> /// 当一个类有静态构造函数时，它的静态成员变量不会被beforefieldinit修饰 /// 就会确保在被引用的时候才会实例化，而不是程序启动的时候实例化 /// </summary> static SingletonStaticInner() { } /// <summary> /// 实例化 /// </summary> internal static SingletonStatic singletonStatic = new SingletonStatic(); } /// <summary> /// 私有构造函数 /// </summary> private SingletonStatic() { Console.WriteLine("我被创建了.静态内部类"); } /// <summary> /// 获取实例 /// </summary> /// <returns></returns> public static SingletonStatic GetInstance() { return SingletonStaticInner.singletonStatic; } public void ShowMessage() { Console.WriteLine("Hello World.静态内部类"); } }
延迟加载（Lazy）
/// <summary> /// 创建一个 Singleton 类(Lazy) /// 该方式是需要.netformwork4+ /// </summary> public class SingletonLazy { private static Lazy<SingletonLazy> singletonLazy = new Lazy<SingletonLazy>(()=>new SingletonLazy()); /// <summary> /// 私有构造函数 /// </summary> private SingletonLazy() { Console.WriteLine("我被创建了.Lazy"); } /// <summary> /// 获取实例 /// </summary> /// <returns></returns> public static SingletonLazy GetInstance() { return singletonLazy.Value; } public void ShowMessage() { Console.WriteLine("Hello World.Lazy"); } }
每一种创建方式测试
创建一个控制台程序，通过多线程对每一种实现方式使用，查看其实例次数分析：
/* 介绍 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 主要解决：一个全局使用的类频繁地创建与销毁。 何时使用：当您想控制实例数目，节省系统资源的时候。 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。 关键代码：构造函数是私有的。 应用实例： 典型的已有应用： 1、windows的任务管理器等 2、IIS的HttpApplication，所有的HttpModule都共享一个HttpApplication实例 在项目中的实际使用场景： 1、日志组件 2、多线程线程池管理 3、网站计数器 4、配置文件管理 */ class Program { static void Main(string[] args) { TaskFactory taskFactory = new TaskFactory(); List<Task> taskList = new List<Task>(); //// 测试--饿汉式 for (int i = 0; i < 5; i++) { taskList.Add(taskFactory.StartNew(() => { SingleObject.GetInstance(); })); } //// 测试--懒汉式 for (int i = 0; i < 5; i++) { taskList.Add(taskFactory.StartNew(() => { SingleObject1.GetInstance(); })); } //// 测试--双重验证 for (int i = 0; i < 5; i++) { taskList.Add(taskFactory.StartNew(() => { SingleObject2.GetInstance(); })); } //// 测试--静态内部类 for (int i = 0; i < 5; i++) { taskList.Add(taskFactory.StartNew(() => { SingletonStatic.GetInstance(); })); } //// 测试--Lazy for (int i = 0; i < 5; i++) { taskList.Add(taskFactory.StartNew(() => { SingletonLazy.GetInstance(); })); } Console.ReadLine(); } }
运行结果：
总结
根据单例模式是每一种实现方式对比分析，在实际使用过程中：建议采用延迟加载（Lazy）
当然，还有其他类似的实现单例的方式，没有写到的，也欢迎大家一起交流，勿喷
