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替代为具体的网络连接类进行使用：
     1. 使用具体类替代泛型，用泛型单例提供类对该具体类达到提供唯一实例的单例实现效果：
     2. 具体类中定义了字段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;
        }

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

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

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