阅读 2

设计模式-单例模式详解

概述

单例模式(Singleton),保证一个类仅有一个实例,并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的方法。

使用场景

处理资源访问冲突

  • 应用程序中的日志处理类
  • 网站的计数器模块

表示全局唯一类

  • 配置信息类
  • 唯一递增 ID 编码生成器

局限性

  • 单例对 OOP 特性的支持不友好

我们知道,OOP 的四大特性是封装、抽象、继承、多态。单例这种设计模式对于其中的抽象、继承、多态都支持得不好。一般单例模式都会违反“基于接口而非实现的设计原则”,也就违背了广义上理解的 OOP 的抽象特性。

  • 单例会隐藏类之间的依赖关系

我们知道,代码的可读性非常重要。在阅读代码的时候,我们希望一眼就能看出类与类之间的依赖关系,搞清楚这个类依赖了哪些外部类。通过构造函数、参数传递等方式声明的类之间的依赖关系,我们通过查看函数的定义,就能很容易识别出来。但是,单例类不需要显示创建、不需要依赖参数传递,在函数中直接调用就可以了。如果代码比较复杂,这种调用关系就会非常隐蔽。在阅读代码的时候,我们就需要仔细查看每个函数的代码实现,才能知道这个类到底依赖了哪些单例类。

  • 单例对代码的扩展性不友好

我们知道,单例类只能有一个对象实例。如果未来某一天,我们需要在代码中创建两个实例或多个实例,那就要对代码有比较大的改动。
你可能会说,会有这样的需求吗?既然单例类大部分情况下都用来表示全局类,怎么会需要两个或者多个实例呢?实际上,这样的需求并不少见。我们拿数据库连接池来举例解释一下。在系统设计初期,我们觉得系统中只应该有一个数据库连接池,这样能方便我们控制对数据库连接资源的消耗。
所以,我们把数据库连接池类设计成了单例类。但之后我们发现,系统中有些 SQL 语句运行得非常慢。这些 SQL 语句在执行的时候,长时间占用数据库连接资源,导致其他 SQL 请求无法响应。为了解决这个问题,我们希望将慢 SQL 与其他 SQL 隔离开来执行。为了实现这样的目的,我们可以在系统中创建两个数据库连接池,慢 SQL 独享一个数据库连接池,其他 SQL 独享另外一个数据库连接池,这样就能避免慢 SQL 影响到其他 SQL 的执行。

  • 单例对代码的可测试性不友好

单例模式的使用会影响到代码的可测试性。如果单例类依赖比较重的外部资源,比如 DB,我们在写单元测试的时候,希望能通过 mock 的方式将它替换掉。而单例类这种硬编码式的使用方式,导致无法实现 mock 替换。

如何实现(Code)

本文实现代码均基于C#。一般实现方式有两种:饿汉式和懒汉式。由于饿汉式,即静态初始化的方式,它是类一加载就实例化的对象,所以要提前占用系统资源。然而懒汉式,又会面临着多线程访问的安全性问题,需要做类似双重锁定的处理才可以保证安全。所以到底使用哪一种方式,取决于实际的需求。

双重锁定(懒汉式)

/// <summary>
/// 单例模式-双重锁定
/// </summary>
public class Singleton
{
    private static Singleton instance;
    private static readonly object syncRoot = new object();//一个只读的进程辅助对象
    private Singleton() { }//私有的构造函数,防止外部程序通过new来实例化它

    public static Singleton Instance()
    {
        if (instance == null)//先判断实例是否存在,不存在再加锁处理
        {
            lock (syncRoot)//确保同一时刻只有一个线程可以进入
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }         
        return instance;
    }
}
复制代码

静态内部类(懒汉式)

/// <summary>
/// 单例模式-静态内部类
/// </summary>
public class Singleton2
{
    private Singleton2() { }

    private static class SingletonInstance
    {
        public static Singleton2 Instance = new Singleton2();
    }

    public static Singleton2  GetInstance()
    {
        return SingletonInstance.Instance;
    }
}
复制代码

静态初始化(饿汉式)

/// <summary>
/// 静态初始化
/// </summary>
public sealed class Singleton3
{
    private static readonly Singleton3 instance = new Singleton3();

    private Singleton3() { }

    public static Singleton3 GetInstance()
    {
        return instance;
    }
}
复制代码

替代方案

  • 工厂模式
  • IOC容器

深入理解

如何理解单例模式中的唯一性?

单例模式的定义中提到,“一个类只允许创建唯一一个对象”。那对象的唯一性的作用范围是什么呢?是指线程内只允许创建一个对象,还是指进程内只允许创建一个对象?答案是后者,也就是说,单例模式创建的对象是进程唯一的。
进程之间是不共享地址空间的,如果我们在一个进程中创建另外一个进程(比如,代码中有一个 fork() 语句,进程执行到这条语句的时候会创建一个新的进程),操作系统会给新进程分配新的地址空间,并且将老进程地址空间的所有内容,重新拷贝一份到新进程的地址空间中,这些内容包括代码、数据(比如 user 临时变量、User 对象)。
所以,单例类在老进程中存在且只能存在一个对象,在新进程中也会存在且只能存在一个对象。而且,这两个对象并不是同一个对象,这也就说,单例类中对象的唯一性的作用范围是进程内的,在进程间是不唯一的。

如何实现线程唯一的单例?

我们通过一个 Map 来存储对象,其中 key 是线程 ID,value 是对象。这样我们就可以做到,不同的线程对应不同的对象,同一个线程只能对应一个对象。

如何实现集群环境下的单例?

首先,我们还是先来解释一下,什么是“集群唯一”的单例。我们还是将它跟“进程唯一”“线程唯一”做个对比。“进程唯一”指的是进程内唯一、进程间不唯一。“线程唯一”指的是线程内唯一、线程间不唯一。集群相当于多个进程构成的一个集合,“集群唯一”就相当于是进程内唯一、进程间也唯一。也就是说,不同的进程间共享同一个对象,不能创建同一个类的多个对象。

我们需要把这个单例对象序列化并存储到外部共享存储区(比如文件)。进程在使用这个单例对象的时候,需要先从外部共享存储区中将它读取到内存,并反序列化成对象,然后再使用,使用完成之后还需要再存储回外部共享存储区。为了保证任何时刻在进程间都只有一份对象存在,一个进程在获取到对象之后,需要对对象加锁,避免其他进程再将其获取。在进程使用完这个对象之后,需要显式地将对象从内存中删除,并且释放对对象的加锁。

如何实现一个多例模式?

跟单例模式概念相对应的还有一个多例模式。那如何实现一个多例模式呢?“单例”指的是,一个类只能创建一个对象。对应地,“多例”指的就是,一个类可以创建多个对象,但是个数是有限制的,比如只能创建 3 个对象。

多例的实现也比较简单,通过一个 Map 来存储对象类型和对象之间的对应关系,来控制对象的个数。

参考资料

关注下面的标签,发现更多相似文章
评论