Unity中C#单例模式使用总结

一、单例模式优点

1. 单例模式核心在于对于某个单例类，在系统中同时只存在唯一一个实例，并且该实例容易被外界所访问；
2. 意味着在内存中，只存在一个实例，减少了内存开销；

二、单例模式特点

1. 只存在唯一一个实例；
2. 提供统一对外访问接口，使得全局可对该单例的唯一实例进行访问；
3. 自行实例化（私有构造函数，不允许外界对其进行实例化）。

三、单例模式使用

1. 资源管理器，资源对象数据的加载和卸载（无状态不需要实例化的对象）；
2. 单一客户端连接服务器等；
3. 生命周期在游戏中永不消毁的对象。

四、单例模式注意点

1. 注意线程安全问题，在多线程、高并发的情况下，可能同时产生多个实例,违背了单例模式。
2. Unity中如果过度使用单例模式，将会导致代码耦合度非常高，脚本与脚本之间的耦合，代码的后续拓展变得非常麻烦。一个过分依赖单例模式的开发者不能成为一个好的开发者，也不会去接触到更多优秀的设计模式。个人推荐ECS 实体 - 组件式编程。
3. Unity中暂时不需要考虑多线程问题，Unity就只有一个主线程和开启多个辅助协程，不会出现多线程并发问题。
4. 控制游戏对象的生成和销毁并不建议使用单例模式，可通过主游戏逻辑InGame进行事件下发，自行管理Update，使用工厂来进行对象的创建和销毁。

五、单例模式常见模式

1. 懒汉模式(最常用)

   1.1 提供私有构造函数;

   1.2 自行实例化;

   1.3 提供唯一实例，并且对外提供全局静态访问接口对该实例进行访问；

• 代码如下：

  /// <summary>
  /// 普通模式
  /// </summary>
  public class Singleton
  {
  private static Singleton _instance = null;
  
  private Singleton()
  {
  }
  
  public static Singleton GetInstance()
  {
  if (_instance == null)
  {
  _instance = new Singleton();
  }
  return _instance;
  }
  }

2. 饿汉模式

   2.1 本类内部预先自行实例化出唯一实例；

   2.2 对外提供唯一访问接口（静态方法），对预先实例化的唯一实例进行访问；

   2.3 私有构造函数；

   代码如下：

   /// <summary>
   /// 饿汉单例模式
   /// </summary>
   public class Singleton
   {
   // 自行预先实例化,内部定义自己唯一实例，只供内部使用 //
   private readonly static  Singleton Instance = new Singleton();
   
   private Singleton()
   {
   // Do Something
   }
   
   // 提供外部访问的静态方法，来对内部唯一实例进行访问 //
   public static Singleton GetInstance()
   {
   return Instance;
   }
   }

3. 双重锁模式（解决线程安全问题）

   3.1 保证多线程中只存在唯一实例

4. 代码如下：

   /// <summary>
   /// 双重锁单例模式
   /// </summary>
   public class Singleton
   {
   private static Singleton _instance = null;
   private static readonly object _syslock = new object();
   private Singleton()
   {
   }
   
   public static Singleton GetInstance()
   {
   // 最开始判断不存在的时候，该类从来未被实例化过 //
   if (_instance == null)
   {
   // 锁定状态，继续搜索是否存在该类的实例 //
   lock (_syslock)
   {
   // 如果不存在，在锁定状态下实例化出一个实例 //
   if (_instance == null)
   {
   _instance = new Singleton();
   return _instance;
   }
   else  // 锁定状态下，存在该类实例，直接返回 //
   {
   return _instance;
   }
   }
   }
   // 该实例本身就已经存在了，直接返回 //
   return _instance;
   }
   }

5. 泛型单例模式

    

   4.1 在一个案例中,我们可能需要使用到不止一个单例模式类,甚至更多。那么此时,使用泛型单例模式模板来实现单例模式,我们可以有两种不同的方法来实现它:

   4.2首先我们来看下泛型模板，我们对泛型类进行约束，T只能是一个Class，并且有一个公共无参构造函数，代码如下：

   using System;
   using UnityEngine;
   
   public class SingletonProvider<T> where T : class ,new()
   {
   private SingletonProvider()
   {
   }
   
   private static T _instance;
   // 用于lock块的对象
   private static readonly object _synclock = new object();
   
   public static T Instance
   {
   get
   {
   if (_instance == null)
   {
   lock (_synclock)
   {
   if (_instance == null)
   {
   // 若T class具有私有构造函数,那么则无法使用SingletonProvider<T>来实例化new T();
   _instance = new T();
   //测试用，如果T类型创建了实例，则输出它的类型名称
   Debug.Log("{0}：创建了单例对象" + typeof(T).Name);
   }
   }
   }
   return _instance;
   }
   set { _instance = value; }
   }
   }

   4.2.1 然后我们定义了一个网络连接类 NetIO,使用单例提供类中的泛型T替代为具体的网络连接类进行使用：
   • 4.2.2 使用具体类替代泛型，用泛型单例提供类对该具体类达到提供唯一实例的单例实现效果：
   • 4.2.3 具体类中定义了字段NetIoCreateTime来存储该类实例化的时间，进行下一步分析该类实例是否是唯一实例，具体类代码如下：

     public class NetIO
     {
     
     public static NetIO GetInstance()
     {
     return SingletonProvider<NetIO>.Instance;
     }
     
     public NetIO()
     {
     this.NetIoCreateTime = DateTime.Now;
     }
     
     public DateTime NetIoCreateTime
     {
     get { return _ct; }
     set { _ct = value; }
     }
     
     private DateTime _ct;
     }

   • 4.2.4 在Unity中Update参数中调用该类，对该类创建时间进行输出

     public void Update()
     {
     Debug.Log(NetIO.GetInstance().NetIoCreateTime);
     }

   • 4.2.5 测试结果如下：
   • 
   • 4.2.6 所有创建时间都一致，证明该类提供单例提供类中的泛型替代，达到了单例模式的效果，提供了该类的唯一实例访问

    

   4.3 在一个案例中,我们可能需要使用到不止一个单例模式类,甚至更多。那么此时,使用泛型单例模式模板来实现单例模式,我们可以有两种不同的方法来实现它:

6. 4.3.1 首先我们来看下泛型模板，我们对泛型类进行约束，T只能是一个Class，并且有一个公共无参构造函数，代码如下：

   using System;
   using UnityEngine;
   
   public class SingletonProvider<T> where T : class ,new()
   {
   private SingletonProvider()
   {
   }
   
   private static T _instance;
   // 用于lock块的对象
   private static readonly object _synclock = new object();
   
   public static T Instance
   {
   get
   {
   if (_instance == null)
   {
   lock (_synclock)
   {
   if (_instance == null)
   {
   // 若T class具有私有构造函数,那么则无法使用SingletonProvider<T>来实例化new T();
   _instance = new T();
   //测试用，如果T类型创建了实例，则输出它的类型名称
   Debug.Log("{0}：创建了单例对象" + typeof(T).Name);
   }
   }
   }
   return _instance;
   }
   set { _instance = value; }
   }
   }

   • 4.3.2 然后我们定义了一个网络连接类 NetIO,使用单例提供类中的泛型T替代为具体的网络连接类进行使用： 使用具体类替代泛型，用泛型单例提供类对该具体类达到提供唯一实例的单例实现效果：
   • 具体类中定义了字段NetIoCreateTime来存储该类实例化的时间，进行下一步分析该类实例是否是唯一实例，具体类代码如下：

     public class NetIO
     {
     
     public static NetIO GetInstance()
     {
     return SingletonProvider<NetIO>.Instance;
     }
     
     public NetIO()
     {
     this.NetIoCreateTime = DateTime.Now;
     }
     
     public DateTime NetIoCreateTime
     {
     get { return _ct; }
     set { _ct = value; }
     }
     
     private DateTime _ct;
     }

   • 在Unity中Update参数中调用该类，对该类创建时间进行输出

     public void Update()
     {
     Debug.Log(NetIO.GetInstance().NetIoCreateTime);
     }

   • 测试结果如下：
   • 所有创建时间都一致，证明该类提供单例提供类中的泛型替代，达到了单例模式的效果，提供了该类的唯一实例访问