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

一、单例模式优点

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

二、单例模式特点

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

三、单例模式使用

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

四、单例模式注意点

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

五、单例模式常见模式

懒汉模式(最常用)

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

泛型单例模式

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

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. 所有创建时间都一致，证明该类提供单例提供类中的泛型替代，达到了单例模式的效果，提供了该类的唯一实例访问