设计模式-单列模式

单列模式（Singleton Pattern）是一种确保一个类只有一个实例，并提供一个全局访问点的设计模式。这种模式在Java中非常常见，尤其是在需要控制资源使用或确保数据一致性的情况下。

模式来源

单列模式的概念最早可以追溯到20世纪90年代，由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides（这四位作者合称为“四人帮”）在他们的著作《设计模式：可复用面向对象软件的基础》中提出。这本书是软件工程领域的一本经典之作，其中介绍了23种设计模式，单列模式就是其中之一。

用处

1.控制实例数量：确保系统中某个类只有一个实例，避免创建多个实例造成资源浪费或数据不一致。

2.提供全局访问点：提供一个全局访问点，方便其他对象访问该实例。

场景

1.配置管理：如日志配置、数据库配置等，通常只需要一个实例。

2.线程池：线程池的实现通常使用单列模式，确保整个应用中只有一个线程池实例。

3.数据库连接：数据库连接通常需要单列模式来管理，以避免创建多个连接实例。

4.硬件访问：如打印机、绘图仪等硬件设备的访问，通常也使用单列模式。

Java中的实现

饿汉式单列

public class Singleton {
    // 饿汉式单列在类加载时就创建实例
    private static final Singleton INSTANCE = new Singleton();

    // 私有构造函数，防止外部直接创建实例
    private Singleton() {}

    // 提供一个全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

饿汉式例子

        想象一下，你去一家餐厅吃饭，餐厅里只有一个服务员（单列实例），他负责接待所有的顾客（全局访问点）。这个服务员就是餐厅的“单列”，确保了服务的一致性和高效性。如果你想要点餐，你只需要对这个服务员说：“嘿，服务员，我要点一份宫保鸡丁！”然后他就会为你提供服务。这个服务员就是餐厅的“单列模式”，他确保了服务的唯一性和高效性。

懒汉式单列（线程安全）

public class Singleton {
    // 懒汉式单列在第一次调用时创建实例
    private static Singleton instance;

    // 私有构造函数，防止外部直接创建实例
    private Singleton() {}

    // 提供一个全局访问点，使用synchronized关键字确保线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式例子

想象一下，你去一家餐厅吃饭，餐厅里只有一个服务员（单列实例），但他不是立即出现的。只有当你需要点餐时，他才会从厨房里走出来（实例化），然后为你提供服务。这种方式更加节省资源，因为只有在需要的时候才会创建实例。如果你想要点餐，你只需要对这个服务员说：“嘿，服务员，我要点一份宫保鸡丁！”然后他就会为你提供服务。这个服务员就是餐厅的“懒汉式单列模式”，他确保了服务的唯一性和高效性，同时避免了资源的浪费。

   在软件开发中，单列模式就像是那个服务员，确保了某个类的实例只有一个，并且提供了一个全局的访问点，让其他对象可以方便地访问这个唯一的实例。

单例模式的优缺点

优点

1.控制实例数量：单列模式确保一个类只有一个实例，这有助于控制资源的使用，避免了不必要的资源浪费。

2.全局访问点：提供了一个全局访问点，使得其他对象可以方便地访问这个唯一的实例。

3.灵活性：单列模式可以很容易地修改为懒汉式或饿汉式，以适应不同的需求和性能要求。

4.易于测试：单列模式的类通常易于测试，因为它们不依赖于外部状态。

5.减少命名空间污染：由于单列模式的全局访问点，可以避免创建多个实例时的命名空间污染。

缺点

1.违反单一职责原则：单列模式的类通常负责创建实例和提供访问点，这可能会违反单一职责原则。

2.隐藏的依赖关系：单列模式可能会导致代码中出现隐藏的依赖关系，因为其他类可能依赖于单列类的全局访问点。

3.测试困难：在某些情况下，单列模式的类可能难以测试，特别是当单列类依赖于外部资源或状态时。

4.并发问题：在多线程环境中，单列模式需要特别注意线程安全问题。虽然可以通过同步机制来解决，但这可能会导致性能问题。

5.扩展困难：单列模式的类通常不容易扩展，因为它们的构造函数是私有的，这使得继承或接口实现变得复杂。

6.全局状态：单列模式的全局访问点可能会导致全局状态的管理问题，这可能会使得代码难以理解和维护。

7.内存泄漏风险：在某些实现中，如果单列类持有对其他对象的引用，而这些对象又持有对单列类的引用，可能会导致内存泄漏。

单列模式在多线程下如何保证线程安全？

1.饿汉式单列模式：

• 实现方式：在类加载时就创建实例，确保实例在多线程环境下是唯一的。
• 优点：简单，线程安全，因为实例在类加载时就已经创建，不需要在运行时进行同步。
• 缺点：如果实例占用资源较多，可能会导致内存浪费。

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

  2.懒汉式单列模式：

• 实现方式：在第一次调用getInstance()方法时创建实例。
• 线程安全的懒汉式：通过同步方法或同步代码块来保证线程安全。

  public class Singleton {
      private static Singleton instance;
      private Singleton() {}
      public static synchronized Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }

  3.双重检查锁定（DCL）：

• 实现方式：在懒汉式的基础上，通过双重检查锁定来减少同步的开销。
• 优点：只有在实例未被创建时才进行同步，提高了效率。

  public class Singleton {
      private volatile static Singleton instance;
      private Singleton() {}
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }

  4.静态内部类：

• 实现方式：利用Java的类加载机制，通过静态内部类来实现单列模式。
• 优点：线程安全，且只有在第一次调用getInstance()方法时才加载内部类，从而创建实例。

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

  5.枚举单列模式：

• 实现方式：使用Java的枚举类型来实现单列模式，这是最简单且线程安全的方式。
• 优点：实现简单，线程安全，且可以防止反序列化重新创建新的对象。

  public enum Singleton {
      INSTANCE;
      public void whateverMethod() {
          // ...
      }
  }

  在多线程环境下，推荐使用静态内部类或枚举的方式来实现单列模式，因为它们既保证了线程安全，又避免了不必要的同步开销。