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个实例，所以在多线程中，懒汉式有线程不安全问题

总结

根据单例模式是每一种实现方式对比分析，在实际使用过程中：

如果是单线程应用环境，建议可以采用懒汉模

如果是多线程应用环境，建议采用静态内部类方式

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。