Java设计模式 - 单例模式

单例模式

这个模式的核心目的是控制实例的创建，确保系统内存中一个类只有一个实例。该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
单例模式的关键点：

1. 私有构造方法：防止外部使用 new 关键字创建多个实例。
2. 静态实例：在类内部创建并持有单一实例。
3. 公共静态方法：提供获取单一实例的方式。

实现单例模式的方式：

1. 饿汉式

饿汉式，顾名思义，类一加载就创建对象。容易产生垃圾对象，浪费内存空间，适用于实例创建开销较小的情况。

public class EagerSingleton {
    // 私有构造方法
    private EagerSingleton() {}
    // 静态实例
    private static EagerSingleton instance = new EagerSingleton();
    // 公共静态方法
    public static EagerSingleton getInstance(){
        return instance;
    }
}

2. 懒汉式

懒汉式实现延迟初始化单例对象，直到第一次使用时才创建实例。此方法在单线程下使用没有问题，多线程下需要同步处理避免线程安全问题。

public class LazySingleton {
    // 私有构造方法
    private LazySingleton() {}
    // 静态实例
    private static LazySingleton instance;
    // 公共静态方法
    public static LazySingleton getInstance() {
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

3. 懒汉式（线程安全）

通过 synchronized 关键字加锁保证线程安全，存在的问题是每一次调用 getInstance 获取实例时都需要加锁和释放锁，这样是非常影响性能的。

public class LazySingleton {
    // 私有构造方法
    private LazySingleton() {}
    // 静态实例
    private static LazySingleton instance;
    // 公共静态方法
    public static synchronized LazySingleton getInstance() {
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

4. 双重检查锁（DCL， 即 double-checked locking）

双重锁检查（Double-Check Locking）是一种优化的懒汉式实现方式，旨在减少多线程环境下的同步开销。具体做法是在获取实例之前先检查实例是否已创建，然后加锁进行创建，并在加锁后再次检查实例，以确保线程安全。

public class DoubleCheckedLockingSingleton {
    // 私有构造方法
    private DoubleCheckedLockingSingleton() {}
    // 静态实例
    private static volatile DoubleCheckedLockingSingleton instance;
    // 公共静态方法
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

5. 枚举单例

枚举是实现单例模式的推荐方式，它由 Java 语言本身提供了对单例模式的支持，因为枚举天生就能保证单一实例。每个枚举常量在类加载时被创建，并且只会创建一次。枚举的设计确保了线程安全和反序列化时的唯一性，因此它是实现单例模式的一种简单且可靠的方法。

public enum EnumSingleton implements Serializable {
    INSTANCE;
    public void doSomething(){
        System.out.println("doSomething");
    }
}

6. 静态内部类

静态内部类利用类加载机制确保线程安全，并且只有在 getInstance() 被调用时才会加载内部类，从而延迟实例创建。

public class StaticInnerClassSingleton {
    // 私有化构造函数，防止外部使用new关键字创建多个实例
    private StaticInnerClassSingleton() {}
    //2、创建静态内部类，并定义一个静态的成员变量，用于存储单例对象
    private static class SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }
    //3、提供静态方法，返回单例对象
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}