单列模式的多种实现方式



  1.  简单双检锁单例模式，CPU开启out-of-order execution优化时,无法保证单例。    

///<summary>
    /// 双检锁单例模式
    ///</summary>
    ///<typeparam name="T"></typeparam>
    public static class Singleton<T> where T : class, new()
    {
        private static T _instance;
        private static readonly object _padLock = new object();

        public static T Instance
        {
            get
            {
                //if _instance!= default(T), 当前实例不为空，直接返回
                if (_instance == default(T))
                {
                    lock (_padLock)
                    {
                        if (_instance == default(T))
                            _instance = new T();
                    }
                }
                return _instance;
            }
        }
    }

2.当实例的构造函数执行时间较长时，先调用C#默认的空构造函数将单例实例化出来，而无需等待。   

/// <summary>
    ///  每个应用程序域的单例模式
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Singleton<T> where T : class, new()
    {
        ///<summary>
        /// 静态只读确保线程安全，并且是单例的
        /// 使用 Lazy 确保延迟加载，并且是线程安全的
        ///</summary>
        private static readonly Lazy<T> _lazy = new Lazy<T>(() => new T(), true);

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

   

///<summary>
    /// 每个应用程序域的单例模式
    ///</summary>
    ///<typeparam name="T"></typeparam>
    public static class Singleton<T> where T : class
    {
        ///<summary>
        /// 懒加载单例实例
        ///</summary>
        public static T Instance
        {
            get
            {
                return Nested.instance;
            }
        }

        private class Nested
        {
            ///<summary>
            /// .net确保在静态构造函数中，在应用程序中线程安全。
            ///</summary>
            internal static readonly T instance = (T)Activator.CreateInstance(typeof(T), true);
        }
    }

    

///<summary>
    /// 每个应用程序域的单例模式
    ///</summary>
    ///<typeparam name="T"></typeparam>
    public static class Singleton<T> where T : class, new()
    {
        private static T _instance;
        private static readonly Mutex _mutex = new Mutex();

        public static T Instance
        {
            get
            {
                //if _instance != default(T), 当实例不为空时，直接返回实例
                if (_instance == default(T))
                {
                    _mutex.WaitOne();
                    if (_instance == default(T))
                    {
                        var temp = new T();
                        //执行当前线程的处理器无法重新排序指令，
                        //使得在对MemoryBarrier进行调用之前进行的存储器访问将在对MemoryBarrier的调用进行跟踪之后执行。
                        Thread.MemoryBarrier();
                        _instance = temp;
                    }
                    _mutex.ReleaseMutex();
                }
                return _instance;
            }
        }
    }

   

///<summary>
    ///  每个应用程序域的单例模式
    ///</summary>
    ///<typeparam name="T"></typeparam>
    public static class Singleton<T> where T : class, new()
    {
        //添加volatile以确保_instance存在于内存中，而不是cpu缓存
        private volatile static T _instance;
        private static readonly object _padLock = new object();

        public static T Instance
        {
            get
            {
                //if _instance!= default(T), 当实例不为空时，直接返回
                if (_instance == default(T))
                {
                    lock (_padLock)
                    {
                        if (_instance == default(T))
                            _instance = new T();
                    }
                }
                return _instance;
            }
        }
    }

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

        public T Instance
        {
            get
            {
                if (instance == null)
                    Interlocked.CompareExchange(ref instance, new T(), null);

                return instance;
            }
        }
    }