C#_单例

目录

把需要做成单例的类继承自 Singleton 脚本即可

单线程中比较安全的单例

多线程中比较安全的单例（虽然多线程能工作，但是效率不高，直接用下一个）

多线程中比较安全的单例（加锁前后两次判断实例是否已存在）

强烈推荐的单例 一： 利用静态构造函数

强烈推荐的单例 二：实现按需创建实例 

---

把需要做成单例的类继承自 Singleton 脚本

项目中需要用到很多的单例时候可以写一个单例模板脚本，让所有需要做成单例模式的脚本继承这个模板即可。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Singleton<T> : MonoBehaviour
where T:MonoBehaviour
{
    private static T m_Instance;

    public static T Instance
    {
        get
        {
            return m_Instance;
        }

    }

    protected virtual void Awake()
    {
        m_Instance = this as T;
    }

}

单线程中比较安全的单例

public sealed class Singleton1
{
    private Singleton1()         //构造函数
    {
    }

    private static Singleton1 instance = null;
    public static Singleton1 Instance
    {
        get
        {
            if (instance == null)
                instance = new Singleton1();

            return instance;
        }
    }
}

上述代码在 Singleton 的静态属性 Instance 中， 只有在 instance 为 null 的时候才创建一个实例以避免重复创建。同时我们把构造函数定义为私有函数， 这样就能确保只创建一个实例。

把类型标记为 sealed ，表示它们不能作为其他类型的基类。

多线程中比较安全的单例（虽然多线程能工作，但是效率不高，直接用下一个）

public sealed class Singleton2
{
    private Singleton2()
    {
    }

    private static readonly object syncObj = new object();

    private static Singleton2 instance = null;
    public static Singleton2 Instance
    {
        get
        {
            lock (syncObj)
            {
                if (instance == null)
                    instance = new Singleton2();
            }
            return instance;
        }
    }
}

为了保证在多线程环境下我们还是只能得到类型的一个实例，需要加上一个同步锁。把Singleton1稍做修改得到了如上代码。

假设有两个线程同时想创建一个实例。由于在一个时刻只有一个线程能得到同步锁，当第一个线程加上锁时，第二个线程只能等待。当第一个线程发现实例还没有创建时，它创建出一个实例。接着第一个线程释放同步锁，此时第二个线程可以加上同步锁，并运行接下来的代码。这个时候由于实例已经被第一个线程创建出来了，第二个线程就不会重复创建实例了，这样就保证了我们在多线程环境中也只能得到一个实例。但是类型 Singleton2 还不是很完美。我们每次通过属性 Instance 得到 Singleton2 的实例，都会试图加上一个同步锁，而加锁是一个非常耗时的操作，在没有必要的时候我们应该尽量避免。

多线程中比较安全的单例（加锁前后两次判断实例是否已存在）

public sealed class Singleton3
{
    private Singleton3()
    {
    }

    private static readonly object syncObj = new object();

    private static Singleton3 instance = null;
    public static Singleton3 Instance
    {
        get
        {
            if (instance == null)
            {
                lock (syncObj)
                {
                    if (instance == null)
                        instance = new Singleton3();
                }
            }
            return instance;
        }
    }
}

Singleton3 中只有当 instance 为 null 即没有创建时，需要加锁操作。当 instance 已经创建出来之后，则无须加锁。因为只在第一次的时候 instance 为 null ，因此只在第一次试图创建实例的时候需要加锁。这样 Singleton3 的时间效率比 Singleton2 要好很多。

强烈推荐的单例 一： 利用静态构造函数

C# 的语法中有一个函数能够确保只调用 一次，那就是 静态构造函数，我们可以利用 C# 这个特性 实现单例模式 如下：

public sealed class Singleton4
{
    private Singleton4() { }

    private static Singleton4 instance = new Singleton4();
    public static Singleton4 Instance
    {
        get
        {
            return instance;
        }
    }
}

Singleton4 的实现代码非常简洁。我们在初始化静态变量 instance 的时候创建一个实例。由于 C# 是在调用静态构造函数时初始化静态变量，.NET 运行时能够确保只调用一次静态构造函数，这样我们就能够保证只初始化一次 instance 。

C# 中调用 静态构造函数 的时机不是由程序员掌控的，而是当 .NET 运行时发现第一次使用一个类型的时候自动调用该类型的 静态构造函数 。因此在 Singleton4 中，实例 instance 并不是第一次调用属性 Singleton4.Instance 的时候创建，而是在第一次用到 Singleton4 的时候就会被创建。假设我们在 Singleton4 中添加一个静态方法，调用该静态函数是不需要创建一个实例的，但如果按照 Singleton4 的方式实现单例模式，则仍然会过早地创建实例，从而降低内存的使用效率。

强烈推荐的单例 二：实现按需创建实例 

最后的一个实现 Singleton5 则很好地解决了 Singleton4 中的实例创建时机过早的问题： 

public sealed class Singleton5
{
    Singleton5()
    {
    }

    public static Singleton5 Instance
    {
        get
        {
            return Nested.instance;
        }
    }

    class Nested
    {
        static Nested()
        {
        }
        internal static readonly Singleton5 instance = new Singleton5();
    }
}

在上述 Singleton5 的代码中，我们在内部定义了一个私有类型 Nested 。当第一次用到这个嵌套类型的时候，会调用静态构造函数创建 Singleton5 的实例 instance 。类型 Nested 只在属性 Singleton5.Instance 中被用到，由于其私有属性他人无法使用 Nested 类型。因此当我们第一次试图通过属性 Singleton5.Instance 得到 Singleton5 的实例时，会自动调用 Nested 的静态构造函数创建实例 instance 。如果我们不调用属性 Singleton5.Instance ，那么就不会触发 .NET 运行时调用 Nested ，也不会创建实例，这样就真正做到了按需创建。