轉載引用了CSDN海濤高軟，燕雙飛等大牛的博客&

https://www.cnblogs.com/liaoguipeng/p/5130144.html

https://blog.csdn.net/yuechuzhao/article/details/46906217----Good Suggestions!

單例模式：(singleton pattern)，簡單說即類的實例在內存中只有一個；

簡單兩種類型的總結如下：

I.寫一個腳本，然後將這個腳本拖放到場景中某個對象身上，千萬註意只拖一次到場景中，我們知道，一旦將腳本托給場景中某個對象，

就變成腳本組件，組件就是對象，因此這個類的實例在場景中有且只有一個，因此從某種意義上講場該腳本組件也就是單例的。

訪問此種單例有兩種方式：

1.getcomponent方法；

2.遊戲中，經常為了獲取方便，比較易用的方式如下（xuhaitao.instance），使用這種方式要註意三點，在場景中有且只有一個該類的腳本組件，

再一個就是該腳本組件所依附的對象在場景中必須是激活的，否則會報空指針異常，最後一點是要將instance=this這樣代碼放在Awake函數中

不要放在Start函數中——防止其它類中調用時此單例尚未賦值實例化，報空錯：

如果腳本是繼承monobehavior，那麽使用起單例來更加簡單。

只需要在Awake（）裏面，添加一句instance = this;

II.

1.公有靜態方法的方法

public class AssetLoader : MonoBehaviour
{

    private static AssetLoader instance;
    private AssetLoader() { }  //禁止外界通過New的方式獲取該類的實例
    public static AssetLoader GetInstance()
    {
        if (instance == null)
        {
            instance 
 
= new AssetLoader();
        }
        return instance;
    }

2.公有靜態屬性的方法

public class AssetLoader : MonoBehaviour
{

    private static AssetLoader instance;
    private AssetLoader() { }  //禁止外界通過New的方式獲取該類的實例
    public static AssetLoader Instance
    {
        get
        {
            if (instance ==null)
            {
                instance = new AssetLoader();
            }
            return instance;
        }
    }

進一步的介紹與用處：

一、單例模式優點

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 保證多線程中只存在唯一實例

/// <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;
    }
}



// 公有屬性
public sealed class Singleton 
{ 
   private static volatile Singleton instance; 
   private static object syncRoot = new Object(); 
   private Singleton() {} 
   public static Singleton Instance 
   { 
      get  
      { 
         if (instance == null)  
         { 
            lock (syncRoot)  
            { 
               if (instance == null)  
                  instance = new Singleton(); 
            } 
         } 
         return instance; 
      } 
   } 
} 

4.泛型單例模式

在一個案例中,我們可能需要使用到不止一個單例模式類,甚至更多。那麽此時,使用泛型單例模式模板來實現單例模式,我們可以有兩種不同的方法來實現它:

• 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. 所有創建時間都一致，證明該類提供單例提供類中的泛型替代，達到了單例模式的效果，提供了該類的唯一實例訪問

Unity單例模式