1. 普通类的单例

懒汉式（首次调用的时候才实例化，非线程安全）

    public class GameManager
    {
        private static GameManager instance;    //单例对象，全局唯一
 
        public static GameManager GetInstance   //获取接口,也可以写成函数形式
        {
            get
            {
                if (instance == null)
                    instance = Activator.CreateInstance<GameManager>();
                return instance;
            }
        }
 
        public void Init()
        {
            Debug.Log("Initialized");
        }
    }
 
 
 
 
    /// <summary>
    /// 调用方式
    /// </summary>
    GameManager.GetInstance.Init();

优点：代码简单，实现方式简单。

缺点：项目中若需要很多类的单例来支撑的话，使用这种方式会让我们编写很多无用的重复代码（每个类都要实现一遍）

适用场景：适合单例使用较少的项目。

饿汉式（在进行实例声明的时候，它就完成了初始化，线程安全，但在不一定会使用到的单例中容易产生垃圾对象，浪费内存）

public class Singleton
{
	//在进行实例声明的时候就完成初始化
    private static Singleton instance = new Singleton();
	
	//同样地，用私有化的构造函数限制外界进行实例化
    Singleton(){}

    //提供给外界进行调用实例的方法
    public static Singleton GetSingleton() 
    {
        return instance;
    }

}

2.?泛型单例（做为单例基类使用）

（进阶版，做为一个基类存在，每当一个类需要做为单例时只要继承他就行，不用每次都再单独构造）

    using System;

    public class Singleton< T > where T : class, new()
    {
        private static T instance = default(T);
        public static T GetInstance()
        {
            if (instance == null)
            {
                instance = new T();
            }
            return instance;
        }
 
    }

/// <summary>
/// 具体类的定义
/// </summary>
public class GameManager : Singleton<GameManager>  
{
    /// <summary>
    /// 初始化游戏
    /// </summary>
    public void InitGame()
    {
        ///init local data
        Debug.Log("Initailized");
    }
}
 
/// <summary>
/// 使用方式
/// </summary>
GameManager.GetInstance().InitGame();

优点：代码相对简单，只需要继承Singleton<T>类就可以实现单例类。

缺点：因为泛型约束中填写了new(),因此子类无法私有化构造函数，子类依然可以通过new来实例化对象。

适用场景：适合单例使用较多的项目。

3. 静态内部类

????静态内部类的方式在实现上比起上边两种稍微复杂一些，但同时兼顾了lazy loding和多线程安全，

public class Singleton
{
    Singleton(){}

    //提供给外界进行调用实例的方法
    public static Singleton GetSingleton() 
    {
        return InitSingleton.Instance;
    }

    //使用静态内部类完成初始化
    private static class InitSingleton 
    { 
        public static Singleton Instance = new Singleton();
    }
}

静态内部类又是如何实现兼顾两者的呢？

? ? 我们知道，静态成员的初始化，是在类进行装载的时候进行的，而在我们没有调用过GetSingleton()方法之前，InitSingleton类没有进行任何调用，
? ? 那么自然，Singleton的单例也没有进行初始化。

而多线程安全的实现方式则和饿汉式一样了；
?

继承MonoBehaviour类的实现方式

4. 简单继承Mono的单例

????MonoBehaviour的子类实现单例模式的方式很简单，只需要创建一个静态的实例然后加上该实例 = this 就可以了

public class Singleton : MonoBehaviour
{
    public static Singleton instance;	//创建静态实例
	
	//防止外部进行额外的实例化将构造函数设为private
    private Singleton()
    {  
    
    }

    void Awake()
    {
        instance = this;
    }

}

优点：在单例进阶版的基础上改进，会在U3D中创建一个空对象并把对应的管理器脚本挂上去，从而对游戏进行

? ? ? ? ? 相应的“特殊”管理。

缺点：必须得调用一次GetInstance才会创建对象。

使用场景：需要在游戏中生成一个空对象（挂载相应的管理脚本）用来实时管理游戏状态的情况。

Unity中继承MonoBehaviour脚本有两个特性：

1. MonoBehaviour不能使用构造函数进行实例化，只能挂载在GameObject上。
2. 上述单例在当前场景中必须只能存在一个该脚本。

当切换场景时，当前场景中的GameObject都会被销毁，这种情况下，单例对象也会被销毁。

5.?DontDestroyOnLoad场景常驻单例

如果不希望切换场景时单例被销毁需要使用Unity的 DontDestroyOnLoad(GameObject obj) 函数。代码如下
?

public class BoxCtrl : MonoBehaviour
{
    private static BoxCtrl _Instance;

    public static BoxCtrl Instance
    {
        get
        {
            if(_Instance==null)
            {
                //创建一个新的物体
                GameObject obj = new GameObject("BoxCtrl");
                //将单例挂载在物体上
                _Instance = obj.AddComponent<BoxCtrl>();
                //使得加载场景时候，物体不会被摧毁
                DontDestroyOnLoad(obj);
            }
            return _Instance;
        }
    }

    public void Test()
    {
        Debug.Log("执行BoxCtrl单例");
    }
}

当然，要确定你确实需要常驻这些Unity?对象，不然不能及时销毁GC 浪费内存。

单例类与静态类在c#中的区别是什么 - 开发技术 - 亿速云

UNITY 单例模式的坑，别写构造函数_草样年华的博客-CSDN博客

单例销毁_【代码篇】不要让单例毁了你的代码_郭晨野的博客-CSDN博客

【Unity技巧】使用单例模式Singleton_candycat-CSDN博客_unity 单例