当前位置：网站首页>创建型模式 - 单例模式Singleton

创建型模式 - 单例模式Singleton

2022-08-02 21:43:00 【Xiaohei.Wang(Wenhao)】

单例模式的定义与特点

创建型模式：
单例模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。

例如，Windows中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

在计算机系统中，还有Windows的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

单例模式有3个特点：

单例类只有一个实例对象
该单例对象必须由单例类自行创建
单例类对外提供一个访问该单例的全局访问点

单例模式的优点和缺点

优点：

单例模式可以保证内存中只有一个实例对象，减少了内存的开销
避免了对资源的多重占用
单例模式的全局访问点，优化了对共享资源的访问

缺点：

没有接口，扩展困难。如需扩展，则需修改原有代码，这违背了开闭原则
在并发测试中，单例模式不利于代码调试
单例模式的功能全部在一个类中、如果功能设计不合理，很容易违背单一职责原则

学习代码：

namespace StudyDesignMode.Singleton
{
    /// <summary>
    /// 单例基类，防多线程问题
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class Singleton<T> where T : class
    {
        protected Singleton() { }
        public static readonly T Instance = new Lazy<T>(() => (T)Activator.CreateInstance(typeof(T), true)).Value;
    }




    /// <summary>
    /// 懒汉模式
    /// </summary>
    public class SingletonL
    {
        #region 懒汉模式
        SingletonL instance; 
        public SingletonL GetInstance()
        {
            if (null == instance)
                instance = new SingletonL();
            return instance;
        }
        #endregion
    }
    /// <summary>
    /// 饿汉模式
    /// </summary>
    public class SingletonE
    {
        #region 饿汉模式        
        SingletonE instance = new SingletonE(); 
        public SingletonE GetInstance()
        {
            return instance;
        }
        #endregion
    }

    /// <summary>
    /// 内部静态模式
    /// </summary>
    public class SingletonJ
    {
        #region 内部静态类       //没啥卵用
        private SingletonJ() { }
        public static SingletonJ getInstance()
        {
            return InnerClass.instance;
        }

        public static class InnerClass
        {
            public static readonly SingletonJ instance = new SingletonJ();
        }
        #endregion
    }

//========================================多地方吃亏而得.==================================
    /// <summary>
    /// 多线程安全的单例模式
    /// </summary>
    public class SingletonA
    {
        private SingletonA() { }
        private volatile static SingletonA m_instance;
        public static SingletonA Instance()
        {
            if (null == m_instance)
            {
                lock (new object())
                {
                    if (null == m_instance)
                    {
                        m_instance = new SingletonA();
                    }
                }
            }
            return m_instance;
        }
    }

    /// <summary>
    /// 系统懒加载式创建
    /// </summary>
    public class SingletonLazy
    {
        private SingletonLazy() { }
        public static readonly SingletonLazy Instance = 
            new Lazy<SingletonLazy>(
                new Func<SingletonLazy>(() => new SingletonLazy())
            ).Value;
    }
}