创建型模式

创建型模式

特点

  • 创建型模式关注点是如何创建对象，其核心思想是要把对象的创建和使用相分离，这样使得两者能相对独立地变换。
  • 创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。

简单/静态工厂SImple Factory

  • 定义

    • 在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

  • 模式结构

    • 包含角色

      • Factory：工厂角色

        • 工厂角色负责实现创建所有实例的内部逻辑

      • Product：抽象产品角色

        • 抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口

      • ConcreteProduct：具体产品角色

        • 具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

    • UML

  • 我的示例

  • 特点

    • 优点

      • 将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易。
      • 在调用工厂类的工厂方法时，由于工厂方法是静态方法，使用起来很方便，可通过类名直接调用，而且只需要传入一个简单的参数即可，在实际开发中，还可以在调用时将所传入的参数保存在XML等格式的配置文件中，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性。
      • 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。
      • 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。

    • 缺点

      • 简单工厂模式最大的问题在于工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则是相违背的。

        • 这个问题导致了工厂模式的诞生

      • 由于工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

      • 使用简单工厂模式将会增加系统中类的个数，在一定程序上增加了系统的复杂度和理解难度。

      • 简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

  • ⭐️ 适用环境

    • 工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

    • 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

      • Spring的Bean对象的初始化

  • 概括

    • 当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

  • 模式实际应用

    • java加密技术

      • 获取不同加密算法的密钥生成器

        • KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

  • 精华总结

    • 创建型模式对类的实例化过程进行了抽象，能够将对象的创建与对象的使用过程分离。
    • 简单工厂模式又称为静态工厂方法模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
    • 简单工厂模式包含三个角色：工厂角色负责实现创建所有实例的内部逻辑；抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。
    • 简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。
    • 简单工厂模式最大的优点在于实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责，但是其最大的缺点在于工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。
    • 简单工厂模式适用情况包括：工厂类负责创建的对象比较少；客户端只知道传入工厂类的参数，对于如何创建对象不关心。

工厂方法：Factory Method

  • 简单工厂和抽象工厂是工厂模式的基础上,分别简单化和复杂化的产物,所以先介绍处于中间位置的工厂模式

  • 引入

    • 简单工厂需要根据用户传入的参数生产所有的同父类的实例类,但是如果新增一个实例类的时候,需要修改简单工厂的源代码,增加了简单工厂的复杂性
    • 工厂方法在简单工厂的基础上引进了抽象父工厂,每一个子工厂专门生产一种产品,这种结构可以在不修改具体工厂类的情况下引进新的产品,如果引进新的产品,则新建一个专门生产该产品的工厂

  • 定义

    • 工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

  • 模式结构

    • 包含角色

      • Product：抽象产品

      • ConcreteProduct：具体产品

      • Factory：抽象工厂

        • 该抽象工厂类定义了返回产品的方法,简单工厂没有抽象工厂父类

      • ConcreteFactory：具体工厂

        • 简单工厂的一个工厂生产所有产品,工厂模式的一个子工厂生产一种产品

    • UML

  • 作者示例

    • UML

  • 我的示例

  • 特点

    • 优点

      • 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。(工厂模式通用的优点)

      • 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了。这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。

        • 解决了简单工厂模式的不足

    • 缺点

      • 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
      • 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象工厂进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

  • ⭐️ 适用环境

    • 客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

      • Spring的Bean对象的初始化

  • 模式应用

    • jdbc的工厂方法

  • 精华总结

    • 工厂方法模式又称为工厂模式，它属于类创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
    • 工厂方法模式包含四个角色：抽象产品是定义产品的接口，是工厂方法模式所创建对象的超类型，即产品对象的共同父类或接口；具体产品实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，它们之间往往一一对应；抽象工厂中声明了工厂方法，用于返回一个产品，它是工厂方法模式的核心，任何在模式中创建对象的工厂类都必须实现该接口；具体工厂是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户调用，返回一个具体产品类的实例。
    • 工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
    • 工厂方法模式的主要优点是增加新的产品类时无须修改现有系统，并封装了产品对象的创建细节，系统具有良好的灵活性和可扩展性；其缺点在于增加新产品的同时需要增加新的工厂，导致系统类的个数成对增加，在一定程度上增加了系统的复杂性。
    • 工厂方法模式适用情况包括：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定。

抽象工厂：Abstract Factory

  • 引入

    • 工厂方法模式中,一个具体的工厂只能生产一种具体产品,如DELL工厂只生产一种笔记本电脑,然而工作和现实中一个具体的工厂,可能生产集中具体的产品,如DELL公司既生产笔记本也生产台式机

    • 产品等级结构

      • 产品等级结构即产品的继承结构,如抽象父类笔记本电脑,子类是DELL的笔记本电脑和MAC的笔记本电脑

    • 产品族

      • 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品

    • 图示

    • 抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构

  • 模式结构

    • AbstractFactory：抽象工厂

      • 该抽象工厂定义了返回多个产品等级结构的方法,这些方法返回多个产品的抽象父类
      • 而工厂方法的抽象工厂只是定义了返回一个产品等级结构的方法,该方法返回一个产品的抽象父类

    • ConcreteFactory：具体工厂

    • AbstractProduct：抽象产品

      • 抽象工厂模式下有多个抽象产品父类,对应了多个产品等级机构
      • 工厂方法模式下只有一个抽象产品父类,对应了一个产品等级结构

    • Product：具体产品

  • 作者示例

    • UML

  • 我的示例

  • 特点

    • 优点

      • 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
      • 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
      • 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

    • 缺点

      • 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。

      • 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。

        • 增加产品族：对于增加新的产品族，工厂方法模式很好的支持了“开闭原则”，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。
        • 增加新的产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，不能很好地支持“开闭原则”。

  • 精华总结

    • 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
    • 抽象工厂模式包含四个角色：抽象工厂用于声明生成抽象产品的方法；具体工厂实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
    • 抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。
    • 抽象工厂模式的主要优点是隔离了具体类的生成，使得客户并不需要知道什么被创建，而且每次可以通过具体工厂类创建一个产品族中的多个对象，增加或者替换产品族比较方便，增加新的具体工厂和产品族很方便；主要缺点在于增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。
    • 抽象工厂模式适用情况包括：一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节；系统中有多于一个的产品族，而每次只使用其中某一产品族；属于同一个产品族的产品将在一起使用；系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

建造者：Builder

  • 引入

    • 无论是在现实世界中还是在软件系统中，都存在一些复杂的对象，它们拥有多个组成部分，如汽车，它包括车轮、方向盘、发送机等各种部件。而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述，建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。
    • 在软件开发中,复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里，建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

  • 定义

    • 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节

  • 模式结构

    • 角色

      • Builder：抽象建造者

        • 抽象建造者类中定义了产品的创建方法和返回方法;

      • ConcreteBuilder：具体建造者

        • 具体建造者类中实现了产品的创建方法和返回方法;

      • Director：指挥者

        • 该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象(适用于有多个具体的建造者的时候)

      • Product：产品角色

    • UML

  • 示例

    • UML

      • 来自菜鸟教程,可以翻看具体代码

  • 模式分析

    • 在客户端代码中，无须关心产品对象的具体组装过程，只需确定具体建造者的类型即可，建造者模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现。

  • 特点

    • 优点

      • 在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
      • z每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象 。
      • 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
      • 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

    • 缺点

      • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制

        • 比如去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"

      • 如内部变化复杂，会有很多的建造类

        • 套餐多种多样,食物组合的算法也就多种多样,导致建造类很多

  • 适用环境

    • 软件开发中有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这一些基本部件不会变，而其组合经常变化的时候

      • 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。
      • 2、JAVA 中的 StringBuilder。

  • 与抽象工厂比较

    • 与抽象工厂模式相比， 建造者模式返回一个组装好的完整产品 ，而 抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。
    • 在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象。
    • 如果将抽象工厂模式看成 汽车配件生产工厂 ，生产一个产品族的产品，那么建造者模式就是一个 汽车组装工厂 ，通过对部件的组装可以返回一辆完整的汽车。
    • ⭐️ 建造者模式更加关注与零件装配的顺序

  • 精华总结

    • 建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。
    • 建造者模式包含如下四个角色：抽象建造者为创建一个产品对象的各个部件指定抽象接口；具体建造者实现了抽象建造者接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象；产品角色是被构建的复杂对象，包含多个组成部件；指挥者负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造
    • 在建造者模式的结构中引入了一个指挥者类，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。
    • 建造者模式的主要优点在于客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象，每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，符合“开闭原则”，还可以更加精细地控制产品的创建过程；其主要缺点在于由于建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，因此其使用范围受到一定的限制，如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。
    • 建造者模式适用情况包括：需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性；需要生成的产品对象的属性相互依赖，需要指定其生成顺序；对象的创建过程独立于创建该对象的类；隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同类型的产品。

原型：Prototype

单例：Singleton

  • 引入

    • 如果一个类的实例对象被频繁的调用和销毁,会给系统资源带来压力,我们可以使用单例模式来解决这种问题
    • 虽然使用静态类也可以实现相似的功能,但是这样仍然不能阻止我们手动去创建对象,我们要的就是只能创建一个对象,而不是不加限制的创建很多个对象

  • 定义

    • 单例类只能有一个实例。
    • 单例类必须自己创建自己的唯一实例。
    • 单例类必须给所有其他对象提供这一实例。

  • 补充

    • 主要解决：一个全局使用的类频繁地创建与销毁。
    • 何时使用：当您想控制实例数目，节省系统资源的时候。
    • 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
    • 关键代码：构造函数是私有的。

  • 特点

    • 优点

      • 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。
      • 允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例

    • 缺点

      • 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
      • 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。(getInstance()和eat()融合在一个单例对象中)
      • 如果单例实例长时间不被使用,容易被高级语言的gc系统回收

  • 实现

    • 懒汉式,线程不安全

      • 代码示例

        public class SingleObject {
  private static SingleObject singleObject;
  private SingleObject(){

        }
        
  public static SingleObject getInstance(){
        
    if (singleObject==null){
        
      // 这里一定要对singleObject进行赋值,而不能直接return SingleObject()
        
      singleObject=new SingleObject();
        
    }
        
    return singleObject;
        
  }
        
}

      • 是否 Lazy 初始化(程序一启动就初始化单例对象,而不是等到用到单例对象的时候才初始化)：是

        • 这就是懒汉式的由来,用到的时候才去创建,听起来贬义,但是确实对性能有好处

      • 是否多线程安全：否

      • 实现难度：易

      • 描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

    • 懒汉式,线程安全

      • 代码示例

        public class SingleObject {
  private static SingleObject singleObject;
  private SingleObject(){

        }
        
  public static synchronized SingleObject getInstance(){
        
    if (singleObject==null){
        
      // 这里一定要对singleObject进行赋值,而不能直接return SingleObject()
        
      singleObject=new SingleObject();
        
    }
        
    return singleObject;
        
  }
        
}

        • 比上面的代码多了一个 synchronized

      • 是否 Lazy 初始化：是

      • 是否多线程安全：是

      • 实现难度：易

      • 描述：这种方式具备很好的 lazy loading(延迟加载)，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

      • 优点

        • 第一次调用才初始化，避免内存浪费。

      • 缺点

        • 必须加锁 synchronized 才能保证单例，但加锁会影响效率。
        • getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

    • ⭐️饿汉式,线程安全

      • 代码示例

        public class SingleObject {
  // 成员变量为private,防止外界访问,外界只能通过getInstance()方法获取该对象,而且必须为static,因为需要在静态方法getInstance()返回
  private static SingleObject singleObject=new SingleObject();
  // 构造方法为private,防止外界创建对象
  private SingleObject(){

        }
        
  // 给外界提供的获取单例对象的方法
        
  public static SingleObject getInstance(){
        
    return singleObject;
        
  }
        
  public void eat(){
        
    System.out.println("singleton is eating");
        
  }
        
}

      • 是否 Lazy 初始化((程序一启动就初始化单例对象,而不是等到用到单例对象的时候才初始化))：否

      • 是否多线程安全：是

        • 初始化静态数据时，Java提供了的线程安全性保证,无需任何同步操作

      • 实现难度：易

      • 描述：这种方式比较常用，但容易产生垃圾对象。

      • 优点

        • 没有加锁，执行效率会提高。

      • 缺点

        • 类加载时就初始化，如果该类后来没有使用,浪费内存。

    • DCL双重检测加锁（double check locking）,线程安全

      • 代码进化之路

          1. 默认懒汉式不会产生额外的对象垃圾（懒加载）,但是不是线程安全的,想要线程安全,需在getInstance()加装synchronized关键字,但是会导致多线程性能下降,那么我们可以把锁的范围放小一点,放到创造新对象的时候在加锁,如代码所示
          public class SingleObject {
  private static SingleObject singleObject;
  private SingleObject(){

          }
          
  public static SingleObject getInstance(){
          
    if (singleObject==null) {
          
      // 锁的范围从方法上缩小到生成单例对象上,提高性能
          
      synchronized (SingleObject.class) {
          
        singleObject = new SingleObject();
          
      }
          
    }
          
    return singleObject;
          
  }
          
}

          • 但是这种看似完美解决的方法,仍然存在问题:虽然加了锁,仍然会有可能创建两个单例对象

              1. 假如线程A和线程B同时调用getInstance()方法，他们同时判断singleObject ==null，因为锁没有加在方法上,得出的结果都是为null，所以线程A和线程B都进入了if代码块了
              1. 假设此时线程A得到CPU的控制权-->进入同步代码块-->创建对象-->返回对象
              1. 线程A完成了以后，此时线程B得到了CPU的控制权。同样是-->进入同步代码块-->创建对象-->返回对象
              1. 那么调用了多次的new,就意味着返回了不止一个对象,所以是线程不安全的
          1. 那我们在上面代码的基础上再来一个判断(double check的由来):即进入同步代码后,再new新对象的时候,需要先判断此时singleObject是否已经是null,如果为不空,则不new,否则new
          public class SingleObject {
  private static SingleObject singleObject;
  private SingleObject(){

          }
          
  public static SingleObject getInstance(){
          
    if (singleObjectnull) {
          
      // 锁的范围从方法上缩小到生成单例对象上,提高性能
          
      synchronized (SingleObject.class) {
          
        // 在同步锁上加上双重判断,如果空,才new一个对象
          
        if (singleObject          null) {
          
          singleObject = new SingleObject();
          
        }
          
      }
          
    }
          
    return singleObject;
          
  }
          
}

          • 但是仍然有问题

          1. 如何解决第二步存在的问题呢?在类的私有静态成员变量上加上volatile关键字#TODO :#这里的作用是防止指令重排，但是实现这个防重排功能是由于volitile关键字的内存屏障功能完成的
          public class SingleObject {
  private static volatile SingleObject singleObject;
  private SingleObject(){

          }
          
  public static SingleObject getInstance(){
          
    if (singleObjectnull) {
          
      // 锁的范围从方法上缩小到生成单例对象上,提高性能
          
      synchronized (SingleObject.class) {
          
        // 在同步锁上加上双重判断,如果空,才new一个对象
          
        if (singleObject          null) {
          
          singleObject = new SingleObject();
          
        }
          
      }
          
    }
          
    return singleObject;
          
  }
          
}

          • 强调

      • JDK 版本：JDK1.5 起

      • 是否 Lazy 初始化：是

      • 是否多线程安全：是

      • 实现难度：较复杂

      • 描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

    • 登记式/静态内部类,线程安全

      • 代码示例

        public class Singleton {  
  private static class SingletonHolder {  
  private static final Singleton INSTANCE = new Singleton();  
  }  
  private Singleton (){}  
  public static final Singleton getInstance() {  
  return SingletonHolder.INSTANCE;  
  }  
}

      • 是否 Lazy 初始化：是

      • 是否多线程安全：是

      • 实现难度：一般

      • 和DCL双重检测加锁比较

        • 相同点

          • 都可以实现线程安全的单例模式,但是这种方法更简单高效,所以对静态域使用延迟初始化，应使用这种方式而不是双检锁方式

        • 不同点

          • 静态内部类方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

      • 和饿汉式相比较

        • 饿汉式

          • Singleton一旦被加载,那么 instance 就会被实例化（没有达到 lazy loading 效果）

        • 静态内部类方式

          • Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance

    • 枚举,线程安全

      • 代码示例

        public enum Singleton {
    //每一个实例都是全局唯一的Sigleton实例
    INSTANCE;
    public void sayHello(){
        System.out.println("hello world");
    }
}

      • 是否 Lazy 初始化：否

      • 是否多线程安全：是

      • 实现难度：易

      • 特点

        • 简洁,自动支持序列化机制，绝对防止多次实例化

  • 几种单例模式的经验之谈

    • 一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种静态内部类方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。
posted @ 2025-03-13 18:11  红豆绿豆abc  阅读(2509)  评论(0)    收藏  举报