设计模式的艺术之道--单例模式

最新推荐文章于 2024-07-11 20:57:29 发布

原创最新推荐文章于 2024-07-11 20:57:29 发布 · 1.3k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #C# #单例模式 #单例模式分析

设计模式专栏收录该内容

29 篇文章

订阅专栏

本文深入探讨了单例模式的设计理念及其实现方式，包括饿汉式与懒汉式的对比分析，以及如何解决多线程环境下单例模式的问题。通过具体的案例——负载均衡器的设计，展示了单例模式的应用。

设计模式的艺术之道–单例模式

声明：本系列为刘伟老师博客内容总结(http://blog.youkuaiyun.com/lovelion)，博客中有完整的设计模式的相关博文，以及作者的出版书籍推荐

本系列内容思路分析借鉴了刘伟老师的博文内容，同时改用C#代码进行代码的演示和分析(Java资料过多 C#表示默哀).

本系列全部源码均在文末地址给出。

本系列开始讲解创建型模式，顾名思义，这类模式主要是为了解决类的创建问题。

创建型模式(Creational Pattern)关注对象的创建过程。分析你怎么来的
创建型模式对类的实例化过程进行了抽象，对用户隐藏了类的实例的创建细节。客户不知道你怎么来的
创建型模式描述如何将对象的创建和使用分离，让用户在使用对象时无须关心对象的创建细节。你用就行，别管我怎么来的。
创建型模式关注点创建什么(What) 由谁创建(Who) 何时创建(When)
6种常见的创建型模式

单例模式

对于一个软件系统的某些类而言，我们无须创建多个实例。举个大家都熟知的例子——Windows任务管理器，只能打开一个窗口。

1.1定义

单例模式 (Singleton Pattern)：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。
只有一个对象，并且这个对象需要对外提供一个访问的方式。(属性或者方法等)
这个唯一实例必须是自己创建(私有化构造函数)，必须自行向整个系统提供这个实例.（公开的属性或者方法）

1.2情景实例

问题描述

负载均衡设计
菜鸟软件公司承接了一个服务器负载均衡(Load Balance)软件的开发工作，由于集群中的服务器需要动态删减，且客户端请求需要统一分发，因此需要确保负载均衡器的唯一性，只能有一个负载均衡器来负责服务器的管理和请求的分发，否则将会带来服务器状态的不一致以及请求分配冲突等问题。如何确保负载均衡器的唯一性是该软件成功的关键。

初步思路
使用单例模式进行系统的设计
这里写图片描述
将负载均衡器LoadBalancer设计为单例类，其中包含一个存储服务器信息的集合serverList，每次在serverList中随机选择一台服务器来响应客户端的请求
代码实现

namespace Singleton
{
    class LoadBalancer
    {
        //私有静态成员变量，存储唯一实例
        private static LoadBalancer instance = null;
        //服务器集合
        private ArrayList serverList = null;
        //私有构造函数
        private LoadBalancer()
        {
            serverList = new ArrayList();
        }
        //公有静态成员方法，返回唯一实例
        public static LoadBalancer GetLoadBalancer()
        {
            if (instance == null)
            {
                instance = new LoadBalancer();
            }
            return instance;
        }
        //增加服务器
        //删除服务器
        //使用Random类随机获取服务器
    }
    class Program
    {
        static void Main(string[] args)
        {
            //创建四个LoadBalancer对象
            LoadBalancer balancer1,balancer2,balancer3,balancer4;
            balancer1 = LoadBalancer.GetLoadBalancer();
            balancer2 = LoadBalancer.GetLoadBalancer();
            balancer3 = LoadBalancer.GetLoadBalancer();
            balancer4 = LoadBalancer.GetLoadBalancer();

            //判断服务器负载均衡器是否相同
    if (balancer1 == balancer2 && balancer2 == balancer3 && balancer3 == balancer4) 
            {
                Console.WriteLine("服务器负载均衡器具有唯一性！");
            }
            Console.Read();
        }
    }
}

虽然创建了四个LoadBalancer对象，但是它们实际上是同一个对象，因此，通过使用单例模式可以确保LoadBalancer对象的唯一性。
现有缺点（未来变化）

由于需要多线程环境，现在出现了创建了多个实例对象的情况。
分析代码当第一次调用getLoadBalancer()方法，instance对象为null值，执行代码instance= new LoadBalancer()，在此过程中，由于要对LoadBalancer进行大量初始化工作，需要一段时间来创建LoadBalancer对象。而在此时，如果再一次调用getLoadBalancer()方法（通常发生在多线程环境中），由于instance尚未创建成功，仍为null值，判断条件(instance== null)为真值，因此代码instance= new LoadBalancer()将再次执行，导致最终创建了多个instance对象，这违背了单例模式的初衷，也导致系统运行发生错误。

如何改进
饿汉式单例类(越早吃饭越好所以一出生就立马创建好)
这里写图片描述
代码演示

namespace Singleton
{
    class EagerSingleton
    {
    //一出生直接创建
        private static  EagerSingleton instance = new EagerSingleton();
        private EagerSingleton()
        { }
        public static EagerSingleton getInstance()
        {
            return instance;
        }
    }
}

懒汉式单例类与线程锁定(这一部分参考自剑指Offer)

和普通方式没什么大的区别，但是创建实例之前需要进行线程锁定(每种语言不太一样）

  class LazySingleton
    {
        private static LazySingleton instance = null;
        private static readonly object syncObject = new object();
        private LazySingleton()
        { }
        public static LazySingleton getInstance()
        { 
            // 每个线程来之前先等待锁
            lock (syncObject)
            {
                if (instance == null)
                {
                    instance = new LazySingleton();
                }
            }
            return instance;
        }
    }
}

性能考虑加锁操作是很耗费性能的加锁只有在第一次的创建实例的时候需要，如果实例已经创建则不需要进行加锁，使用双重锁定进行性能优化(脑海中想象一下代码的运行过程)

 class LazySingleton2
    {
        private static LazySingleton2 instance = null;
        //程序运行时创建一个静态只读的辅助对象
        private static readonly object syncRoot = new object();
        private LazySingleton2() { }
        public static LazySingleton2 GetInstance()
        {
            //第一重判断，先判断实例是否存在，不存在再加锁处理
            if (instance == null)
            {
                //加锁的程序在某一时刻只允许一个线程访问
                lock (syncRoot)
                {
                    //第二重判断
                    if (instance == null)
                    {
                        instance = new LazySingleton2();  //创建单例实例
                    }
                }
            }
            return instance;
        }
    }

饿汉式单例类与懒汉式单例类比较

饿汉式单例类：无须考虑多个线程同时访问的问题；调用速度和反应时间优于懒汉式单例；资源利用效率不及懒汉式单例；系统加载时间可能会比较长(考虑简单，性能略低)
懒汉式单例类：实现了延迟加载；必须处理好多个线程同时访问的问题；需通过双重检查锁定等机制进行控制，将导致系统性能受到一定影响(考虑复杂，资源利用效率高)

1.3模式分析

动机和意图

如何保证一个类只有一个实例并且这个实例易于被访问？
(1) 全局变量：可以确保对象随时都可以被访问，但不能防止创建多个对象
(2) 让类自身负责创建和保存它的唯一实例，并保证不能创建其他实例，它还提供一个访问该实例的方法

一般结构

单例模式只包含一个单例角色：
-Singleton（单例）：全局的唯一存在对象

改进的优点

提供了对唯一实例的受控访问
可以节约系统资源，提高系统的性能

现存的缺点

扩展困难（缺少抽象层）
单例类的职责过重
由于自动垃圾回收机制，可能会导致共享的单例对象的状态丢失

适用场景
(1) 系统只需要一个实例对象，或者因为资源消耗太大而只允许创建一个对象
(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例
举例:小王去国际大酒店吃饭(国际大酒店的老板是一个单例) 电脑品牌机的组装(华硕联想可能有一天突然屏幕换成了空间触摸的所有电脑都得换)
实例源代码
GitHub地址
百度云地址:链接: https://pan.baidu.com/s/1hsEhXUO 密码: 8xqu