Unity单例模式

转载引用了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;
        }
    }

进一步的介绍与用处：

一、单例模式优点

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

二、单例模式特点

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

三、单例模式使用

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

四、单例模式注意点

注意线程安全问题，在多线程、高并发的情况下，可能同时产生多个实例,违背了单例模式。
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.饿汉模式

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

posted @ 2018-03-27 12:31 小柏树阅读(4968) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

小柏树