【设计模式】一文带你搞懂Java中的“单例模式”

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

        需要额外注意的是，单例模式只能有一个实例，且必须创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。

        简单来说，单例类由私有静态成员变量、私有构造函数和公共静态方法构成，公共静态方法提供了一个全局访问点，用于返回类的唯一实例。这个方法通常被称为getInstance()。

public class Singleton {  
    // 私有静态成员变量，存储唯一实例  
    private static Singleton instance;  
  
    // 私有构造函数，防止外部代码通过new创建实例  
    private Singleton() {}  
  
    // 公共静态方法，返回类的唯一实例  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
  
    // 其他方法...  
}  
  
// 使用示例  
public class Test {  
    public static void main(String[] args) {  
        Singleton singleton1 = Singleton.getInstance();  
        Singleton singleton2 = Singleton.getInstance();  
        // singleton1 和 singleton2 实际上是同一个实例  
        System.out.println(singleton1 == singleton2); // 输出 true  
    }  
}

         单例模式的实现非常简单易懂，我们可以创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo 类使用 SingleObject 类来获取 SingleObject 对象。

        创建一个SingleObject类。

public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
 
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
 
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

        从类中获取唯一对象：

public class SingletonPatternDemo {
   public static void main(String[] args) {
 
      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      //显示消息
      object.showMessage();
   }
}

         执行程序即可查看结果。

         单例模式有以下几种实现方式。

        1.饿汉式

这种方式比较常用，但容易产生垃圾对象
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

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

         2.懒汉式+双检锁

在懒汉式基础上加入双重检验锁，保证线程安全和性能。

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

        3.静态内部类

使用静态内部类来实现懒汉式单例模式，保证线程安全和性能。这种方式能达到双检锁方式一样的功效，但实现更简单。

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

        4.枚举 

使用枚举来实现单例模式，保证线程安全和防止反射攻击。是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
1）将已经有的class转换成枚举单例

@Data
public class Person {
    private String name;
    private int age;
}

public enum PersonEnum {
    INSTANCE;

    private Person instance;
    private PersonEnum(){
        instance = new Person();
    }

    public Person getInstance() {
        return instance;
    }
}

2）直接新建枚举类

public enum PersonSingleton {
    INSTANCE;

    private String name;
    public String getName() {
        return name;
    }
}

        单例模式主要解决的问题就是频繁创建和销毁全局使用的类实例的问题，当我们需要控制实例数目、节省系统资源时就可以使用单例模式。该模式需要保证一个类只有一个实例，并提供一个全局访问点来访问该实例，其关键就在于它的构造函数是私有的。例如，设备管理器就被设计为单例模式，如果电脑连接了多台打印机，在电脑打印文件时，只有一台打印机真正打印了文件，而非所有打印机同时打印文件。

        单例模式的优点是内存中只有一个实例，减少内存开销，尤其是频繁创建和销毁实例时（如管理学院首页页面缓存）；避免资源的多重占用（如写文件操作）。但它没有接口，不能继承。且与单一职责原则冲突（一个类应该只关心内部逻辑，而不关心实例化方式）。

        单例模式的主要应用场景列举如下：

1. 配置管理类：在应用程序中，配置信息（如数据库连接信息、应用设置等）通常需要在整个应用程序中共享，并且这些配置信息在应用程序的生命周期内不会改变。使用单例模式可以确保配置信息的全局唯一性，并提供一个统一的访问点。

2. 资源管理类：对于一些昂贵的资源，如数据库连接、文件句柄、线程池等，使用单例模式可以避免频繁地创建和销毁这些资源，从而提高性能和节省资源。单例模式可以确保整个应用程序中只有一个资源管理器实例，负责资源的分配和回收。

3. 日志管理类：在应用程序中，日志记录是一个常见的需求。使用单例模式可以确保整个应用程序中只有一个日志管理器实例，负责日志的收集、处理和输出。这样可以保证日志信息的一致性和有序性。

4. 工厂类：在某些情况下，工厂类本身不需要被频繁地创建和销毁，而是需要根据不同的条件创建不同的对象。使用单例模式可以确保工厂类的全局唯一性，并通过工厂类提供的方法来创建所需的对象。

5. 线程安全的共享对象：在多线程环境下，某些对象需要被多个线程共享，并且这些对象的访问需要是线程安全的。使用单例模式可以确保这些共享对象的全局唯一性，并通过适当的同步机制来保证线程安全。

6. 状态管理类：在应用程序中，有时需要维护一些全局状态信息，如当前登录的用户、应用程序的当前模式等。使用单例模式可以确保这些状态信息的全局唯一性，并提供一个统一的访问点来更新和查询状态信息。

7. 缓存类：缓存是提高应用程序性能的一种常用手段。使用单例模式可以确保缓存实例的全局唯一性，从而避免缓存数据的重复和冲突。同时，单例模式还可以提供对缓存数据的统一管理和维护。

         在使用单例模式时，我们也有注意以下几点：

• 线程安全：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成实例被多次创建。
• 延迟初始化：实例在第一次调用 getInstance() 方法时创建。
• 序列化和反序列化：重写 readResolve 方法以确保反序列化时不会创建新的实例。
• 反射攻击：在构造函数中添加防护代码，防止通过反射创建新实例。
• 类加载器问题：注意复杂类加载环境可能导致的多个实例问题。