单例模式基本概念详细描述

单例模式：简单的说它就是一个静态的类对象

在unity 里的单例模式有多种

1. 普通非mono的单例模式

public class Singoton{
    private Singoton _instance;
    public  Singoton instance
    {
        get
        {
            if(_instance==null)
            {
                return _instance;
            }
            return null;
        }
        set;
    }
}

2. 继承了Monobeh  的单例

public class Singoton:MonoBehaviour{
    private Singoton _instance;
    public  Singoton instance
    {
        get
        {
            if(_instance==null)
            {
                _instance=GameObject.Find("对象").GetComponet<Singoton>();
                return _instance;
            }
            return null;
        }
        set;
    }
}

3. 多线程单例：

1. 简单的多线程

public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

　上述实现是线程安全的。这个线程在共享的object上取出了一把锁，然后在创建实例以前检查这个实例是否被创建了。这个保护了内存屏障问题（lock保证了所有的读取操作是在LOCK获得以后发生的，所有的unlock保证了所有的写操作在lock 释放以后发生的），这样就保证了一个线程只能创建一个实例（每次只有一个线程在这段代码中运行），不巧的是，性能上来说，锁变成了每次都必须的当这个实例被响应的时候。

　　注意除了在锁当中锁住typeof(Singleton)这种类型的以外，我锁住了一个静态私有的变量，对于这个类来说。如果是锁 的一个对象的话，其他的类可以进入并且锁住（比如Type）这样会造成性能风险的问题甚至死锁。这是我的大体偏好 - 也许可能的话，只有锁住对象才能达到最终的目的，或者某些文章说锁是为了达到一些特别的目的。（比如等待或者脉冲一个队列）。通常来说这样的对象应该被设置成私有的。这样会让写线程安全更加的容易。

2. 多线程 双重锁定

public sealed class Singleton
{
    private static Singleton instance = null;
    private static readonly object padlock = new object();

    Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }
}

　　这个实现尝试了线程安全，当然并没必要每次都要取出lock,但是这种方式有如下4个缺点：

• 这种方式JAVA中是无效的。也许你会认为我这是在说废话，但是我觉得这是值得你去了解的。JAVA内存模型中新对象的引用被分配到实例之前并不能保证构造函数完成初始化，JAVA 内存模型重新工作（在1.5版本中），但是双重检查锁依然是坏的，在不带volatile 的变量（比如C#）。
• 不带任何的记忆屏障，在ECMA CLI规格中也是破碎的。也许在.NET 2.0以下是安全的，但是我更倾向于不依赖于哪些强类型的语义，特别的说，对于安全性来说这是值得怀疑的。如果把变量变成 volatile的是可以运行的，明确的内存屏障会进行响应，虽然后面有些情况专家都不能完全同意屏障是必须的。我打算尝试避免站在对的或者错误的立场上去回答这个问题！
• 容易报错。这种模式要像上面一样的精确 - 任何的大的改动都会造成正确性和性能方面的冲击。
• 依然没有后面说的那种写法好。

3.  不完全lazy，但线程安全不用锁

public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    // 显示的static 构造函数
    //没必要标记类型 - 在field初始化以前
    static Singleton()
    {
    }

    private Singleton()
    {
    }

    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}
 

如果要在多线程里使用单例模式：要给单例上锁防止多处调用产生的bug

 

 

参考：https://www.cnblogs.com/kmsfan/p/4562323.html