简单聊聊设计模式之单例模式

设计模式之-----单例模式

1. 设计模式的类型

• 创建型模式
  1. 单例模式（Singleton）
  2. 工厂模式（Factory Method）
  3. 抽象工厂模式（Abstract Factory）
  4. 原型模式（Prototype）
  5. 建造者模式（Builder）
• 结构型模式
  1. 适配器模式（Adapter）
  2. 桥接模式（Bridge）
  3. 组合模式（Composite）
  4. 装饰器模式（Decorator）
  5. 外观模式（Facade）
  6. 享元模式（Flyweight）
  7. 代理模式（Proxy）
• 行为型模式
  1. 责任链模式（Chain Of Responsibility）
  2. 命令模式（Command）
  3. 解释器模式（Interpreter）
  4. 迭代器模式（Iterator）
  5. 中介者模式（Mediator）
  6. 备忘录模式（Memento）
  7. 观察者模式（Observer）
  8. 状态模式（State）
  9. 策略模式（Strategy）
  10. 模板模式（Template Method）
  11. 访问者模式（Visitor）

设计模式的六大原则

1. 开闭原则
   • 开闭原则的意思是：对扩展开放，对修改关闭。在程序进行拓展的时候，不能修改原有的代码，实现一个热拔插的效果。简而言之，是为了使程序扩展性更好，易于维护和升级，想要达到这样的效果，我们需要使用接口和抽象类。
2. 里氏代换原则
   • 里氏代换原则是面向对象设计的基本准则之一，里氏代换意思是：任何基类出现的地方，子类一定可以出现，只有当派生类可以替换掉基类，且软件单位的功能不受影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充，实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体体现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
3. 依赖倒转原则
   • 这个原则是开闭原则的基础，具体内容是，针对接口编程，依赖于抽象而不依赖于具体。
4. 接口隔离原则
   • 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好，它还有另外一个意思是：降低类之间的契合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
5. 迪米特原则、又称最少知道原则
   • 迪米特原则是指：一个实体应当尽量少与其他实体之间发生相互作用，使得系统功能模块相对独立。
6. 合成复用原则
   • 合成复用原则是指：尽量使用合成/聚合得方式，而不是使用继承。

单例模式

简介

• 单例模式是java中最简单得设计模式之一，这种模式属于创建型设计模式，它提供了一种创建对象的最佳方式，这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建，这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

  注意：

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

优点

• 在内存中只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
• 避免对资源的多重占用。

缺点

• 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心其内部逻辑，而不关心外部怎么来进行实例化。

场景

• 要求生产唯一序列号

• 创建一个对象需要消耗的资源过多，比如I/O与数据库的连接等等。

实现

• 在java中实现单例模式的方式主要有四种，分别为

• 饿汉式

  /**
   * @ClassName Demo
   * @Description: TODO 饿汉式
   * @Author qywang
   * @Date 2020/6/27
   * @Version V1.0
   **/
  public class Demo {
  
      private static final Demo demo = new Demo();
  
      private Demo() {
      }
  
      public static Demo getInstance() {
          return demo;
      }
  }
  

  • 描述
    • 这种方式比较常用，但是容易产生垃圾对象。它基于ClassLoader机制避免了多线程的同步问题。
  • 优点
    • 没有加锁，执行效率很高。
  • 缺点
    • 类加载时就初始化，浪费内存。

• 懒汉式

  /**
   * @ClassName Demo
   * @Description: TODO 懒汉式，使用double checking双重检查以及volatile关键字保证线程安全以及禁止指令重排
   * @Author qywang
   * @Date 2020/6/27
   * @Version V1.0
   **/
  public class Demo {
  
      private static volatile Demo demo;
  
      private Demo() {
      }
  
      public static Demo getInstance() {
          if (null == demo) {
              synchronized (Demo.class) {
                  if (null == demo) {
                      demo = new Demo();
                  }
              }
          }
          return demo;
      }
  }
  

  • 描述
    • 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。只是在实现的时候较复杂。

• 静态内部类

  /**
   * @ClassName Demo
   * @Description: TODO
   * @Author qywang
   * @Date 2020/6/27
   * @Version V1.0
   **/
  public class Demo {
  
      private Demo() {
      }
  
      public static class DemoHolder {
          private static final Demo demo = new Demo();
      }
  
      public static Demo getInstance() {
          return DemoHolder.demo;
      }
  }
  

  • 描述
    • 这种方式能达到双检锁方式一样的功效，但实现更简单。

• 枚举

  /**
   * @ClassName Demo
   * @Description: TODO
   * @Author qywang
   * @Date 2020/6/27
   * @Version V1.0
   **/
  public enum Demo {
  
      INSTANCE;
  
      public void sayHello(){
          System.out.println("hello world");
  }
  }
  /**
   * @ClassName Demo1
   * @Description: TODO
   * @Author qywang
   * @Date 2020/6/27
   * @Version V1.0
   **/
  public class Demo1 {
      public static void main(String[] args) {
          Demo instance = Demo.INSTANCE;
          instance.sayHello();
      }
  }
  
  

  • 描述
    • 这是实现单例的最佳方法，它更简洁，自动支持序列化机制，不但线程安全，序列化也是安全的。