设计模式之单例模式（Singleton Pattern）简记

创建原则

保证一个类只有一个实例，并提供全局访问点。

使用位置

1. 要求生产唯一序列号。
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

懒汉模式 vs 饿汉模式

• 懒汉模式：很懒。在调用的时候才会创建单例。(延迟加载)
• 饿汉模式：很饿。在系统加载的时候就会创建单例。(预加载)

	懒汉模式	饿汉模式
优点	第一次调用的时候才初始化，避免内存浪费	因为不用加锁就可以保证线程安全，所以执行效率高
缺点	必须加锁才能保证线程安全，加锁则会影响性能	类加载的时候就会初始化，造成内存浪费

示例

/// <summary>
/// 懒汉模式（延迟加载，非线程安全）
/// </summary>
public class LazyLoadSingleton
{
    private static LazyLoadSingleton m_instance = null;
    private LazyLoadSingleton()
    {

    }
    public static LazyLoadSingleton GetInstance()
    {
        if (m_instance == null)
        {
            m_instance = new LazyLoadSingleton();
        }
        return m_instance;
    }
}

/// <summary>
/// 饿汉模式（预加载，线程安全）
/// </summary>
public class PreLoadSingleton
{
    private static PreLoadSingleton m_instance = new PreLoadSingleton();
    private PreLoadSingleton()
    {

    }
    public static PreLoadSingleton GetInstance()
    {
        return m_instance;
    }
}

反射与泛型

再根据我之前分享转载的一篇文章：
https://blog.csdn.net/f_957995490/article/details/103719818
分别进一步编写上面两个的使用反射而创建的泛型基类单例模式。代码如下：
首先是要引用到的系统库，再创建一个泛型的基类。

using System;
using System.Reflection;

public abstract class Singleton<T> where T : Singleton<T>
{
    protected Singleton() { }
}

之后便是运用到反射的两种单例模式。

/// <summary>
/// 单例（延迟加载：懒汉模式）
/// --- 该模式多线程时并不安全，但Unity一般情况下只为单线程，故可以不考虑。
/// </summary>
/// <typeparam name="T">对应的子类</typeparam>
public abstract class LazyLoadSingleton<T> : Singleton<T> where T : LazyLoadSingleton<T>
{
    protected LazyLoadSingleton() { }

    private static T m_instance = null;
    public static T GetInstance()
    {
        if (m_instance == null)
        {
            ConstructorInfo[] ctors;
            //获取public的构造方法
            ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.Public);
            //一般情况单例不需要public的构造方法
            if (ctors.Length != 0)
                throw new Exception("Singleton cannot have Public Constructor()!");
            //先获取所有非public的构造方法
            ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic);
            //从ctors中获取无参的构造方法
            ConstructorInfo ctor = Array.Find(ctors, c => c.GetParameters().Length == 0);
            if (ctor == null)
                throw new Exception("Non-public Constructor() not found!");
            //调用构造方法
            m_instance = ctor.Invoke(null) as T;
        }
        return m_instance;
    }

    public virtual void Clear()
    {
        m_instance = null;
    }
}

/// <summary>
/// 单例（预加载：饿汉模式）
/// </summary>
/// <typeparam name="T">对应的子类</typeparam>
public abstract class PreLoadSingleton<T> : Singleton<T> where T : PreLoadSingleton<T>
{
    protected PreLoadSingleton() { }

    private readonly static T m_instance = NewT();
    private static T NewT()
    {
        ConstructorInfo[] ctors;
        //获取public的构造方法
        ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.Public);
        //一般情况单例不需要public的构造方法
        if (ctors.Length != 0)
            throw new Exception("Singleton cannot have Public Constructor()!");
        //先获取所有非public的构造方法
        ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic);
        //从ctors中获取无参的构造方法
        ConstructorInfo ctor = Array.Find(ctors, c => c.GetParameters().Length == 0);
        if (ctor == null)
            throw new Exception("Non-public Constructor() not found!");
        return ctor.Invoke(null) as T;
    }
    public static T GetInstance()
    {
        return m_instance;
    }
}

内部类单例模式

懒汉线程并不安全

再多线程的情况下，懒汉模式的线程并不安全：多线程的单例对象会出现不一致等情况。要想避免这种情况的“懒汉”，可以有两种方式，一种是线程锁，另一种是内部类实现单例。
这里只分享一下内部类的方式，代码如下：

public class InnerClassSingleton
{
    private InnerClassSingleton()
    {

    }
    private static class InnerClass
    {
        public static InnerClassSingleton m_instance = new InnerClassSingleton();
    }
    public static InnerClassSingleton GetInstance()
    {
        return InnerClass.m_instance;
    }
}

泛型的基类内部类单例模式。

/// <summary>
/// 单例（内部类）
/// </summary>
/// <typeparam name="T">对应的子类</typeparam>
public abstract class InnerClassSingleton<T> : Singleton<T> where T : InnerClassSingleton<T>
{
    protected InnerClassSingleton() { }

    /// <summary>
    /// 内部类
    /// </summary>
    private static class InnerClass
    {
        public static T instance = NewT();
        private static T NewT()
        {
            ConstructorInfo[] ctors;
            //获取public的构造方法
            ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.Public);
            //一般情况单例不需要public的构造方法
            if (ctors.Length != 0)
                throw new Exception("Singleton cannot have Public Constructor()!");
            //先获取所有非public的构造方法
            ctors = typeof(T).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic);
            //从ctors中获取无参的构造方法
            ConstructorInfo ctor = Array.Find(ctors, c => c.GetParameters().Length == 0);
            if (ctor == null)
                throw new Exception("Non-public Constructor() not found!");
            return ctor.Invoke(null) as T;
        }
    }

    public static T GetInstance()
    {
        return InnerClass.instance;
    }
}

当然如果是Unity的话，Unity一般情况下只为单线程，故一般情况下可以不用考虑。

参考链接

1. https://www.jianshu.com/p/b1527d5b0ac4
2. https://blog.csdn.net/f_957995490/article/details/103719818