单例模式 - Unity

单例设计模式

单例模式是指一个类只有一个实例，且提供一个全局访问的属性，访问此单例。
单例模式是我们设计模式中用的最多的一个设计模式之一。它非常普遍，也十分简单，实现也十分容易。

类的结构

横线代表 静态字段 或 静态方法

说明：

1. 单例类的无参构造函数必须私有 - 防止外部创建类
2. 提供全局静态实例接口

实现方法 - Unity中的实现

• 饿汉模式
• 懒汉模式（线程安全）
• 泛型基类 - 创建单例 Unity 脚本组件

饿汉模式

/*
    游戏控制器（单例）
    饿汉单例
*/
public class GameController
{
    private static GameController _instance = new GameController();

    public static GameController Instance { get => _instance; }

    private GameController() { }

    public void ShowHashCode() => Debug.Log("对象类的哈希:" + _instance.GetHashCode());
}

测试

public class Example1 : MonoBehaviour
{
    void Start()
    {
        GameController gameController1 = GameController.Instance;
        GameController gameController2 = GameController.Instance;
        GameController gameController3 = GameController.Instance;

        gameController1.ShowHashCode();
        gameController2.ShowHashCode();
        gameController3.ShowHashCode();

        if (gameController1 == gameController2 && gameController2 == gameController3)
        {
            print("三个单例相同");
        }
    }
}

我们可以得出我们所得到的单例类，是相同的。

结论：饿汉模式可以保证线程的安全，写法也相对简单，但是可以会造成内存的浪费。（当我们没有使用到这个单例类时，就造成了内存的浪费，因为饿汉模式实例的创建在类加载就完成了）

---

懒汉模式（线程安全）

/*
    音频控制器
    懒汉单例（线程安全，双重检查）
*/
public class AudioController
{
    private static object _sync = new object();
    private static volatile AudioController _instance;
    
    public static AudioController Instance
    {
        get
        {
        	//双重检查
            if (_instance == null)
            {
                lock(_sync)
                {
                    if (_instance == null)
                    {
                        _instance = new AudioController();
                    }
                }
            }
            return _instance;
        }
    }

    public void Show() => Debug.Log("此为音频控制器单例类");
}

测试

public class Example2 : MonoBehaviour
{
    private void Start()
    {
        AudioController.Instance.Show();
    }
}

我们通过双重检查的方式去避免多个线程的同时进入，创建多个实例。
在静态实例中添加 volatile 避免内容的易失性，在多核处理器中，因为不同的CPU处理时，内存读入和写出没有及时更新造成的。

结论：懒汉模式双重检查这种方法，即保证了懒加载的作用，同时又保证了线程安全性。非常推荐使用。

泛型单例基类 - Unity脚本组件单例

这个方法主要是针对 Unity 的脚本组件单例实现。它可以通过继承的方式，非常方便的创建单例脚本组件。
单例基类

public abstract class SingletonBase<T> : MonoBehaviour
    where T : Component
{
    private static T _instance;

    public static T Instance { get => _instance; }

    protected virtual void Awake()
    {
        if (_instance == null) 
            _instance = this as T;
        else 
            Destroy(this);
    }

    protected virtual void OnDestroy()
    {
        if (_instance == this) 
            _instance = null;
    }
}

/*
	玩家类此时为脚本组件单例，可作为组件放入GameObject中
*/
public class Player : SingletonBase<Player>
{
    public void Show() => print("此类为玩家单例类");
}

测试

public class Example3 : MonoBehaviour
{
    public void Start()
    {
        Player.Instance.Show();
    }
}

由于Unity不允许脚本组件自行 new 对象，而是统一由 Unity 来创建，所以我们使用 Awake 来初始化实例。

细节：如果有对象在 Awake 或 OnEnable 函数中调用这个单例的实例，有可能会出现实例为 null 的现象，这里我们需要将单例类脚本顺序提前，防止出现为 null。通过 Edit -> Project Settings -> Script Execution Order 来设置脚本顺序。

结论：通过泛型的方法，可以十分方便的创建单例类。由于实例是在 Aawke 函数中赋值的，所以代码尽量不要在 Awake 和 OnEnable 函数中调用单例脚本类的实现。

利与弊

单例模式优点：

• 方便调用，共享资源 - 由于提供了全局属性
• 确保类的实例只有一个 - 减少了内存的开销
• 避免资源重复

单例模式缺点：

• 由于单例模式一般没有接口，他要想实现扩展十分困难。一定程度违背了开闭原则
• 单例模式也一定程度上违背了迪米特法则，所有的类都可以访问。这样会造成了类的关系混乱。
• 由于单例类的代码基本都在类里面，会造成代码的臃肿，降低代码的可读性，可靠性。同时也一定程度的违背了单一职责原则。

我们不应该随便乱用单例模式，需考虑清楚，尽量减少对单例的依赖。单例模式并不会降低代码的耦合性，相反如果乱用，还会大大降低代码的可读性和可靠性。

注意：在使用单例时，需减少类对单例类的依赖，从而提高代码的质量。

这些便是我对单例模式在Unity中的运用的简单见解，希望能帮到大家，谢谢。😮