当前位置: 移动技术网 > IT编程>开发语言>.net > c#设计模式之单例模式

c#设计模式之单例模式

2019年11月02日  | 移动技术网IT编程  | 我要评论

性别的谎言,确山房屋出租,998新开魔域

c#设计模式之单例模式

场景描述

单例模式对于我们来说一点也不模式,是一个常见的名称,单例模式在程序中的实际效果就是:确保一个程序中只有一个实例,并提供一个全局访问点,节省系统资源

单例模式无论是在实际开发中还是在软件应用中比较常见,比如,windows系统的任务管理器、iis的httpapplication、实际项目中的日志组件等等

实现方式

   单例模式为了实现一个实例,那么只有不把实例创建暴露出去,只通过类本身来创建实例,为了实现效果,需要定义一个私有构造函数

  单例模式实现方式有:饿汉式、懒汉式、双重验证式、静态内部类

  下面分别对每一种实现方式做一个简单的实例,以及其优缺点

  饿汉式

   

   /// <summary>
    /// 创建一个 singleton 类(饿汉式)
    /// 这种方式比较常用,但容易产生垃圾对象。
    ///优点:没有加锁,执行效率会提高。
    ///缺点:类加载时就初始化,浪费内存。
    ///它基于 classloder 机制避免了多线程的同步问题,不过,instance 在类装载时就实例化,
    ///虽然导致类装载的原因有很多种,在单例模式中大多数都是调用 getinstance 方法,
    ///但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance 显然没有达到 lazy loading 的效果。
    /// </summary>
    public class singleobject
    {
        //创建 singleobject 的一个对象
        private static singleobject instance = new singleobject();

        //让构造函数为 private,这样该类就不会被实例化
        private singleobject() {
            console.writeline("我被创建了.饿汉式");
        }

        //获取唯一可用的对象
        public static singleobject getinstance()
        {
            return instance;
        }

        public void showmessage()
        {
            console.writeline("hello world.饿汉式");
        }
    }

 

  懒汉式

    

  /// <summary>
    /// 创建一个 singleton 类(懒汉式)
    /// 这种方式具备很好的 lazy loading,能够在多线程中很好的工作,但是,效率很低,99% 情况下不需要同步。
    /// 优点:第一次调用才初始化,避免内存浪费。
    /// 缺点:懒汉式在单个线程中没有问题,但多个线程同事访问的时候就可能同事创建多个实例,而且这多个实例不是同一个对象。
    /// </summary>
    public class singleobject1
    {
        //创建 singleobject 的一个对象
        private static singleobject1 instance;

        //让构造函数为 private,这样该类就不会被实例化
        private singleobject1() { }

        //获取唯一可用的对象
        public static singleobject1 getinstance()
        {
            if (instance == null)
            {
                instance = new singleobject1();
                console.writeline("我被创建了.懒汉式");
            }
            return instance;
        }

        public void showmessage()
        {
            console.writeline("hello world.懒汉式");
        }
    }

 

  双重验证式

 

    /// <summary>
    /// 创建一个 singleton 类(双重验证)
    /// 这种方式具备很好的 lazy loading,能够在多线程中很好的工作,但是,效率很低,99% 情况下不需要同步。
    /// 优点:第一次调用才初始化,避免内存浪费,线程安全。
    /// 缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率。
    /// </summary>
    public class singleobject2
    {
        //创建 singleobject 的一个对象
        private static singleobject2 instance;

        // 定义一个标识确保线程同步
        private static readonly object locker = new object();


        //让构造函数为 private,这样该类就不会被实例化
        private singleobject2() { }

        //获取唯一可用的对象
        public static singleobject2 getinstance()
        {
            //// 如果为空,那么就加锁,创建实例
            if (instance == null)
            {
                lock (locker)
                {
                    //// 枷锁成功后,在做一次非空判断,避免在加锁期间以创建了实例而导致重复创建
                    if (instance == null)
                    {
                        instance = new singleobject2();
                        console.writeline("我被创建了.双重验证");
                    }
                }
            }
            return instance;
        }

        public void showmessage()
        {
            console.writeline("hello world.双重验证");
        }
    }

 

 

  静态内部类

   

  /// <summary>
    /// 创建一个 singleton 类(静态内部类) 
    /// 这种方式不用加锁,在效率上和内存使用上都比较优秀
    /// 克服了饿汉模式的不足饿汉模式执行效率高,由于在类加载的时候初始化导致内存浪费
    /// </summary>
    public class singletonstatic
    {
        /// <summary>
        /// 内部类
        /// </summary>
        public class singletonstaticinner
        {
            /// <summary>
            /// 当一个类有静态构造函数时,它的静态成员变量不会被beforefieldinit修饰
            /// 就会确保在被引用的时候才会实例化,而不是程序启动的时候实例化
            /// </summary>
            static singletonstaticinner() { }

            /// <summary>
            /// 实例化
            /// </summary>
            internal static singletonstatic singletonstatic = new singletonstatic();
        }

        /// <summary>
        /// 私有构造函数
        /// </summary>
        private singletonstatic() {
            console.writeline("我被创建了.静态内部类");
        }

        /// <summary>
        /// 获取实例
        /// </summary>
        /// <returns></returns>
        public static singletonstatic getinstance()
        {
            return singletonstaticinner.singletonstatic;
        }

        public void showmessage()
        {
            console.writeline("hello world.静态内部类");
        }
    }

 

  每一种创建方式测试

   创建一个控制台程序,通过多线程对每一种实现方式使用,查看其实例次数分析:

/*
介绍
意图:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
主要解决:一个全局使用的类频繁地创建与销毁。
何时使用:当您想控制实例数目,节省系统资源的时候。
如何解决:判断系统是否已经有这个单例,如果有则返回,如果没有则创建。
关键代码:构造函数是私有的。
应用实例:
典型的已有应用:
1、windows的任务管理器等
2、iis的httpapplication,所有的httpmodule都共享一个httpapplication实例
在项目中的实际使用场景:
1、日志组件
2、多线程线程池管理
3、网站计数器
4、配置文件管理
*/

  
class program { static void main(string[] args) { taskfactory taskfactory = new taskfactory(); list<task> tasklist = new list<task>(); //// 测试--饿汉式 for (int i = 0; i < 5; i++) { tasklist.add(taskfactory.startnew(() => { singleobject.getinstance(); })); } //// 测试--懒汉式 for (int i = 0; i < 5; i++) { tasklist.add(taskfactory.startnew(() => { singleobject1.getinstance(); })); } //// 测试--双重验证 for (int i = 0; i < 5; i++) { tasklist.add(taskfactory.startnew(() => { singleobject2.getinstance(); })); } //// 测试--静态内部类 for (int i = 0; i < 5; i++) { tasklist.add(taskfactory.startnew(() => { singletonstatic.getinstance(); })); } console.readline(); } }

 

 

  运行结果:

  

  通过结果可以看出:懒汉式实际创建了2个实例,所以在多线程中,懒汉式有线程不安全问题

总结

  根据单例模式是每一种实现方式对比分析,在实际使用过程中:

  如果是单线程应用环境,建议可以采用懒汉模

  如果是多线程应用环境,建议采用静态内部类方式

 

如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复

相关文章:

验证码:
移动技术网