c# 设计模式之单例模式
场景描述
单例模式对于我们来说一点也不模式, 是一个常见的名称, 单例模式在程序中的实际效果就是: 确保一个程序中只有一个实例, 并提供一个全局访问点, 节省系统资源
单例模式无论是在实际开发中还是在软件应用中比较常见, 比如, Windows 系统的任务管理器, IIS 的 HttpApplication, 实际项目中的日志组件等等
实现方式
单例模式为了实现一个实例, 那么只有不把实例创建暴露出去, 只通过类本身来创建实例, 为了实现效果, 需要定义一个私有构造函数
单例模式实现方式有: 饿汉式, 懒汉式, 双重验证式, 静态内部类
下面分别对每一种实现方式做一个简单的实例, 以及其优缺点
饿汉式
- /// <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. 静态内部类");
- }
- }
每一种创建方式测试
创建一个控制台程序, 通过多线程对每一种实现方式使用, 查看其实例次数分析:
- /*
- 介绍
- 意图: 保证一个类仅有一个实例, 并提供一个访问它的全局访问点.
- 主要解决: 一个全局使用的类频繁地创建与销毁.
- 何时使用: 当您想控制实例数目, 节省系统资源的时候.
- 如何解决: 判断系统是否已经有这个单例, 如果有则返回, 如果没有则创建.
- 关键代码: 构造函数是私有的.
- 应用实例:
- 典型的已有应用:
- 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();
- }));
- }
- Console.ReadLine();
- }
- }
运行结果:
通过结果可以看出: 懒汉式实际创建了 2 个实例, 所以在多线程中, 懒汉式有线程不安全问题
总结
根据单例模式是每一种实现方式对比分析, 在实际使用过程中:
如果是单线程应用环境, 建议可以采用懒汉模
如果是多线程应用环境, 建议采用静态内部类方式
来源: https://www.cnblogs.com/xiaoXuZhi/p/designPattern_single.html