1 解决反序列化导致的单例破坏现象#

这里的单例问题是，如果对一个可序列化对象进行反序列化，会创建一个新的对象，这就违背了我们想要全局单例的目标。因此要重写readResolve方法。

1
package org.example.sigletons;
2

3
import java.io.Serializable;
4

5
public class Singleton1 implements Serializable {
6
    private Singleton1(){}
7
    private static final Singleton1 INSTANCE = new Singleton1();
8
    public Singleton1 getInstance() {
9
        return INSTANCE;
10
    }
11
    public Object readResolve() {
12
        return INSTANCE;
13
    }
14
}

2 使用枚举实现单例模式#

1
package org.example.sigletons;
2

3
import java.io.IOException;
4
import java.io.InputStream;
5
import java.util.Properties;
6

7
public enum Singleton2 {
8
    INSTANCE;
9
    private final Properties properties;
10
    private Singleton2() {
11
        properties = new Properties();
12
        String configFile = "application.properties";
13
        System.out.println("ConfigurationManager: Initializing and loading " + configFile);
14
        try(InputStream inputStream = Singleton2.class.getClassLoader().getResourceAsStream(configFile)){
15
            if(inputStream == null){
16
                System.out.println("ConfigurationManager: Sorry, unable to find " + configFile);
17
                // 在实际应用中，这里可能抛出异常或有更复杂的错误处理
18
                return;
19
            }
20
            properties.load(inputStream);
21
            System.out.println("ConfigurationManager: Configuration loaded successfully.");
22
        }catch (IOException e) {
23
            e.printStackTrace();
24
        }
25
    }
26
    public String getProperty(String key) {
27
        return properties.getProperty(key);
28
    }
29
    public String getProperty(String key,String defaultValue) {
30
        return properties.getProperty(key, defaultValue);
31
    }
32

33
    // 可以添加其他需要的方法，比如重新加载配置等（需要考虑线程安全）
34
    public void listProperties() {
35
        properties.forEach((key, value) -> System.out.println(key + "=" + value));
36
    }
37
}
38
class TestSingleton2 {
39
    public static void main(String[] args) {
40
        Singleton2 singleton2 = Singleton2.INSTANCE;
41
        singleton2.listProperties();
42
    }
43
}

💎 枚举单例：全面解答这些问题！📜✨

枚举单例是一种非常推荐的单例实现方式，因为它不仅简单、易用，还天然地具备线程安全和防止反序列化、反射破坏单例的能力。接下来，我们重点针对 枚举单例 来回答这些问题！

问题 1：枚举单例是如何限制实例个数的？#

枚举单例通过枚举的机制天然地保证：

枚举类的每一个枚举实例（如单例对象）都在 类加载阶段 就完成初始化，并且整个应用程序中只有一个实例。
枚举类型底层由 JVM 的实现机制保证，它不像普通类那样允许通过反射或 new 额外创建实例。

示例：#

1
public enum SingletonEnum {
2
    INSTANCE; // 枚举单例实例
3

4
    public void doSomething() {
5
        System.out.println("Doing something...");
6
    }
7
}

使用方式：#

即便通过 SingletonEnum.INSTANCE 多次获取，得到的始终是同一个实例。

1
SingletonEnum instance1 = SingletonEnum.INSTANCE;
2
SingletonEnum instance2 = SingletonEnum.INSTANCE;
3
System.out.println(instance1 == instance2); // 输出：true

问题 2：枚举单例在创建时是否有并发问题？#

枚举单例天然线程安全，因为：

枚举类型的初始化由 JVM 保证，是在类加载时完成的。
类加载过程是线程安全的，JVM 使用了类加载的同步机制，保证枚举单例的初始化不会因多线程而发生竞争。

举例：#

即使多个线程同时调用 SingletonEnum.INSTANCE，它们都会得到在类加载阶段构造好的唯一对象，无需额外同步。

问题 3：枚举单例能否被反射破坏单例？#

不会！ 枚举类型的结构特殊，无法被反射破坏单例。这是因为：

枚举的构造器是私有的，并且其底层会检测反射调用。
如果尝试通过反射显式调用枚举类的构造器，JVM 会抛出 IllegalArgumentException。

验证代码：#

1
import java.lang.reflect.Constructor;
2

3
public class EnumReflectionTest {
4
    public static void main(String[] args) {
5
        try {
6
            // 获取枚举的构造器
7
            Constructor<SingletonEnum> constructor = SingletonEnum.class.getDeclaredConstructor();
8
            constructor.setAccessible(true);
9
            SingletonEnum instance = constructor.newInstance(); // 反射创建枚举对象
10
        } catch (Exception e) {
11
            e.printStackTrace(); // 会抛出 IllegalArgumentException
12
        }
13
    }
14
}

运行结果：#

1
java.lang.IllegalArgumentException: Cannot reflectively create enum objects

问题 4：枚举单例能否被反序列化破坏单例？#

枚举单例天然具备防止反序列化破坏的特性，原因是：

Enum 类型的序列化机制是由 JVM 内部实现的，不走普通的对象序列化流程。
反序列化枚举对象时，JVM 会直接返回枚举类中的现有实例，而不是从序列化流中创建新对象。

验证代码：#

1
import java.io.*;
2

3
public class EnumSerializationTest {
4
    public static void main(String[] args) throws IOException, ClassNotFoundException {
5
        SingletonEnum instance1 = SingletonEnum.INSTANCE;
6

7
        // 序列化枚举对象
8
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("enum_singleton.obj"));
9
        oos.writeObject(instance1);
10
        oos.close();
11

12
        // 反序列化枚举对象
13
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("enum_singleton.obj"));
14
        SingletonEnum instance2 = (SingletonEnum) ois.readObject();
15

16
        // 判断是否破坏单例
17
        System.out.println(instance1 == instance2); // 输出：true，单例没有破坏
18
    }
19
}

问题 5：枚举单例属于懒汉式还是饿汉式？#

枚举单例本质上属于饿汉式单例。它的特点是在类加载阶段完成初始化：

枚举的实例在类加载时就被创建并初始化。
即使程序中从未访问过 SingletonEnum.INSTANCE，枚举实例依然会被加载。

优点：#

线程安全，无需为单例初始化额外编写同步代码。
实现简洁，JVM 自动保证。

缺点：#

如果枚举实例较多，并且包含较大的初始化逻辑，会导致类加载阶段性能开销增加。

问题 6：枚举单例如果希望加入一些初始化逻辑，该如何做？#

可以通过添加枚举的构造方法和静态方法来实现初始化逻辑。枚举的构造方法是私有的，可以用来在实例创建时执行初始化。

修改代码：#

1
public enum SingletonEnum {
2
    INSTANCE; // 枚举单例实例
3

4
    private String configuration;
5

6
    // 枚举的构造方法
7
    SingletonEnum() {
8
        // 初始化逻辑
9
        configuration = "System Configuration Loaded";
10
    }
11

12
    public String getConfiguration() {
13
        return configuration;
14
    }
15
}

测试：#

1
public class TestEnumInitialization {
2
    public static void main(String[] args) {
3
        SingletonEnum instance = SingletonEnum.INSTANCE;
4
        System.out.println(instance.getConfiguration()); // 输出：System Configuration Loaded
5
    }
6
}

分析：#

枚举类型的构造器会在类加载时调用，且只调用一次。
可用枚举构造器实现单例实例的初始化逻辑。

总结#

为何枚举单例完美适合单例模式？

它是天生线程安全的，JVM 保障了枚举实例的唯一性。
枚举实例不能通过反射或序列化破坏。
枚举的初始化流程天然符合饿汉式单例的特点。

3 Double Check#

https://meowrain.cn/archives/volatile-shi-xian-dan-li-mo-shi-de-shuang-zhong-suo

1
package cn.meowrain;
2

3
public class DoubleSingleton {
4
    private static volatile DoubleSingleton INSTANCE = null;
5
    public static DoubleSingleton getInstance() {
6
        if(INSTANCE != null) {
7
            return INSTANCE;
8
        }
9
        synchronized (DoubleSingleton.class){
10
            if(INSTANCE != null) {
11
                return INSTANCE;
12
            }
13
            INSTANCE = new DoubleSingleton();
14
            return INSTANCE;
15
        }
16
    }
17
}

4 静态内部类懒汉式创建线程安全单例#

1
package cn.meowrain;
2

3
public class Singleton2 {
4
    private Singleton2(){}
5
    // 问题1： 属于懒汉式还是饿汉式
6
    private static class LazyLoader{
7
        static final Singleton2 INSTANCE = new Singleton2();
8
    }
9
    // 在创建的时候是否有并发问题
10
    public static Singleton2 getInstance() {
11
        return  LazyLoader.INSTANCE;
12
    }
13
}