当前位置:首页 > 服务端 > 设计模式系列-单例模式

设计模式系列-单例模式

2022年11月09日 21:18:02服务端13

        今天单位有自己的食堂啦,发邮件收了工卡之后统一拿去激活,以后就用工卡去食堂吃饭啦,早上2元,中午10元,晚上3元,都是自助噢,很爽,不过还是有一推人没有第一时间激活卡,也有的人激活卡了忘记自己激活了,我就是其中一个,无奈下我只好到食堂自己去激活卡了,餐厅只有一个机会卡的柜台所以激活的时候需要排队,还好我来的早,提前搞定,刚出门时就看又一批激活工卡的人来啦。

        下班后。不例外继续到食堂吃饭,便宜嘛自然人也就不少,当然也包括激活工卡的人,吃饭是心里就暗自想,这不就是设计模式里面的一种场景吗? 一个餐厅只有一个激活卡的柜台。在餐厅的作用域内提供了一个全局的访问点。

        1.模拟该场景:

          首先分析一个这个场景,首先:

          ① 我们需要一个餐厅类(Restaurant)。

          ② 接下来我们还要设计一个柜台类(Counter),餐厅包含柜台,并且只能拥有一个柜台。

          ③ 柜台类中包含一个用来激活工卡(ActivationCard)的功能,好让员工可以在餐厅用餐。

          废话不多说模拟场景代码如下:

    // 餐厅类
     public  class Restaurant
    {
         // 餐厅包含柜台
         public  static Counter counter =  new Counter();
    }

     // 柜台类
     public  class Counter
    {
         // 激活工卡方法
         public  void ActivationCard()
        {
             // 激活工卡的过程
            Console.WriteLine( " 工卡激活成功! ");
        }
    }

     static  void Main( string[] args)
    {
           // 此时前往餐厅办理激活工卡
            Counter counter = Restaurant.counter;
          counter.ActivationCard();
    }

       这时,似乎不出来代码中有什么问题,但是仔细想想,如果这个时候我在调用激活工卡的时候将获取到的柜台对象重新实例化一次呢?仿佛凭空多制造出了一个柜台的感觉一样,为了确保我们在同一个范围内只有一个柜台实例我们可以考虑单例模式。

       2.引入单例模式

         那么如何让同一个范围内的对象仅有一个实例呢?

         我们可以类的定义中做手脚,改装后的柜台类如下:

    // 柜台类
     public  class Counter
    {
         // 定义一个私有的静态柜台
         private  static Counter instance;

         // 私有构造方法,禁止外部实例化该类型
         private Counter()
        {
        }

         public  static Counter GetCounterInstance()
        {
             if (instance ==  null)
            {
                 // 类型内部可以实例化私有构造实例
                instance =  new Counter();
            }
             return instance;
        }

         // 激活工卡方法
         public  void ActivationCard()
        {
             // 激活工卡的过程
            Console.WriteLine( " 工卡激活成功! ");
        }
    }

       那么柜台是属于餐厅的,必然要给餐厅中安装柜台,平且让餐厅提供激活工卡的服务。餐厅类代码如下:

    // 餐厅类
     public  class Restaurant
    {
         // 激活工卡服务,返回柜台对象(对应显示现实中,指向柜台的位置)
         public Counter ActivationCardService()
        {
             return Counter.GetCounterInstance();
        }
    }

       主函数调用代码如下:

       static  void Main( string[] args)
      {
             // 餐厅实例
            Restaurant res =  new Restaurant();
             // 进入餐厅找到柜台,激活工卡
            res.ActivationCardService().ActivationCard();
      }

       这时一个最基本的单例模式就体现出来了,前面介绍过,单例模式:就是保证一个类仅有一个实例,并提供一个访问它的全局访问点。

         现在看来上面的代码确实做到了这一点,但是在多线程情况下会怎样呢?我们来看获得餐厅实例的方法,这个方法里面实现了仅创建一个实例的逻辑,代码如下:

      public  static Counter GetCounterInstance()
     {
             if (instance ==  null)
            {
                 // 类型内部可以实例化私有构造实例
                instance =  new Counter();
            }
             return instance;
     }

         如果这是两个线程同时访问,那么就会造成同时创建了两个实例,因为两个线程到达这段代码时,该实例都是未创建的,那么如何解决这个问题呢?在实例化方法中加入一个临界区是一个很好的解决办法,这样就能保证一个线程进去临界区时,另一个线程在临界区外面等待,代码如下:

    private  static  readonly  object obj =  typeof( object);
         public  static Counter GetCounterInstance()
        {
             // 加入临界区 当一个线程进入,后面线程等待
             lock (obj)
            {
                 if (instance ==  null)
                {
                     // 类型内部可以实例化私有构造实例
                    instance =  new Counter();
                }
            }
             return instance;
        }

 

       这个时候就解决了线程同步的问题了,在多线程环境下也会只有一个实例被创建,成为了真真正正的单例模式!

       那么在考虑一个问题,回到我们之前的激活工卡场景中,排队的人中有很多卡已经激活自己却不知道的,也就是说,当很多线程执行创建实例的代码时,实例已经是创建过的,那么不必要实例化的线程我们能不能就不让它们进入临界区,减少系统的性能开销?

        代码如下:

private  static  readonly  object obj =  typeof( object);
         public  static Counter GetCounterInstance()
        {
             // 当实例未被实例化在进入临界区
             if (instance ==  null)
            {
                 // 加入临界区 当一个线程进入,后面线程等待
                 lock (obj)
                {
                     if (instance ==  null)
                    {
                         // 类型内部可以实例化私有构造实例
                        instance =  new Counter();
                    }
                }
            }
             return instance;
        }

       这下就是我们传说中的单例模式了,并且对性能也进行了优化。

      3.C#版的单例模式

       那么根据C#的语言特性,实现单例模式又是什么样子呢?

       ①我们可以吧GetCounterInstance()方法 替换成 C#的属性。

       ②我们可以使用密封类,阻止类型的派生,避免多实例化对象。

       ③使用静态并且只读的私有字段存放类型的唯一实例

      代码如下:

  // 柜台类
     public  sealed  class Counter
   {
         // 在第一次调用类成员时,初始化唯一实例
         private  static  readonly Counter instance =  new Counter();

         private Counter()
        {
        }

         // 返回类型实例属性
         public  static Counter Instance
        {
             get
            {
                 return instance;
            }
        }

         // 激活工卡方法
         public  void ActivationCard()
        {
             // 激活工卡的过程
            Console.WriteLine( " 工卡激活成功! ");
        }
   }

      晕。当我想完时,晚饭已经凉了。算了,这不就是程序员的生活嘛?

作者:王波洋
来源链接:https://www.cnblogs.com/doubleliang/archive/2011/12/28/2305434.html

版权声明:
1、JavaClub(https://www.javaclub.cn)以学习交流为目的,由作者投稿、网友推荐和小编整理收藏优秀的IT技术及相关内容,包括但不限于文字、图片、音频、视频、软件、程序等,其均来自互联网,本站不享有版权,版权归原作者所有。

2、本站提供的内容仅用于个人学习、研究或欣赏,以及其他非商业性或非盈利性用途,但同时应遵守著作权法及其他相关法律的规定,不得侵犯相关权利人及本网站的合法权利。
3、本网站内容原作者如不愿意在本网站刊登内容,请及时通知本站(javaclubcn@163.com),我们将第一时间核实后及时予以删除。


本文链接:https://www.javaclub.cn/server/69104.html

标签: 设计模式
分享给朋友: