最简单单例模式（非线程安全）

public class Singleton<T> where T : new()
{
    private static T _instance;



    public static T Instance {
        get
        {
            if (_instance == null)
            {
                _instance = new T();
            }

            return _instance;
        }
    }
}

这是最简单，用途最广泛得单例模板，但是这时候如果有俩个线程同时调用这个单例?，那么有可能存在其中一个将另一个覆盖得问题，使得其中一个调用为空，不使用多个线程，可以无忧使用。

线程安全加锁的单例模式

using Object = System.Object;

public class Singleton<T> where  T : new()
{
    private static T _instance;
    
    private static readonly Object lockObj = new Object();
    protected Singleton()
    {
        
    }

    public static T Instance {
        get
        {
            if (_instance == null)
            {
                lock (lockObj)
                {
                    if (_instance == null)
                    {
                        _instance = new T();
                    }
                    return _instance;
                }
            }

            return _instance;
        }
    }
}

在需要返回单例对象的时候， lockObj会向内存申请一块互斥锁，需要执行完锁中的栈代码才会解锁。如果这个时候有俩个线程同时抢占一块锁（锁的本质就是在内存中开辟一块值为1的空间），那么谁先抢到谁先占用，另一个线程则需要等待解锁后才可以进行调用。这里就解决了线程安全性。

这里首次instance 判空是为了防止每次单例调用都会申请锁，从而浪费不必要的空间和时间，

锁也是防止线程种使用高频率资源数据和代码段使用的延迟调用和安全性检测。

使用Lazy<T>加载实现

提示：这里

public class Singleton<T> where T : new()
{
    private static readonly Lazy<T> instance = new Lazy<T>(()=> new T());

    public static T Instance
    {
        get
        {
            return instance.Value;
        }
    }
}

.NET4或以上的版本支持Lazy<T>来实现延迟加载，它用最简洁的代码保证了单例的线程安全和延迟加载特性。

但是相较于其他方式，这个方式的性能消耗要略高一些，如果不是非得使用这个方式。