Singleton 模式

/**
 * 饿汉式：类加载时就创建实例
 * 优点：简单、线程安全
 * 缺点：不支持延迟加载，可能浪费资源
 */
public class EagerSingleton {
    // 类加载时就创建实例
    private static final EagerSingleton instance = new EagerSingleton();

    // 私有构造函数
    private EagerSingleton() {
        // 初始化代码
    }

    // 返回唯一实例
    public static EagerSingleton getInstance() {
        return instance;
    }
}

/**
 * 懒汉式：第一次使用时创建实例
 * 警告：线程不安全，多线程环境下可能创建多个实例！
 */
public class UnsafeLazySingleton {
    private static UnsafeLazySingleton instance = null;

    private UnsafeLazySingleton() {}

    public static UnsafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new UnsafeLazySingleton();
        }
        return instance;
    }
}

/**
 * 同步方法懒汉式
 * 优点：线程安全
 * 缺点：每次获取实例都需要同步，性能较差
 */
public class SyncedLazySingleton {
    private static SyncedLazySingleton instance = null;

    private SyncedLazySingleton() {}

    public static synchronized SyncedLazySingleton getInstance() {
        if (instance == null) {
            instance = new SyncedLazySingleton();
        }
        return instance;
    }
}

/**
 * 双重检查锁（Double-Checked Locking）
 * 优点：延迟加载、线程安全、性能良好
 * 注意：必须使用 volatile 关键字
 */
public class DCLSingleton {
    // volatile 防止指令重排序
    private static volatile DCLSingleton instance = null;

    private DCLSingleton() {
        // 初始化代码
    }

    public static DCLSingleton getInstance() {
        // 第一次检查：避免不必要的同步
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                // 第二次检查：确保只有一个实例被创建
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

/**
 * 静态内部类方式（Holder 模式）
 * 优点：延迟加载、线程安全、代码简洁
 * 原理：利用类加载机制保证线程安全
 */
public class HolderSingleton {
    // 私有构造函数
    private HolderSingleton() {
        // 初始化代码
    }

    // 静态内部类，延迟加载
    private static class Holder {
        private static final HolderSingleton INSTANCE = new HolderSingleton();
    }

    // 返回实例
    public static HolderSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

/**
 * 枚举单例（Effective Java 推荐）
 * 优点：
 *   1. 线程安全
 *   2. 防止反射攻击
 *   3. 防止序列化破坏
 *   4. 代码简洁
 */
public enum EnumSingleton {
    INSTANCE;  // 唯一实例

    // 添加业务方法
    public void doSomething() {
        System.out.println("Singleton is working");
    }

    // 可以添加属性
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        EnumSingleton singleton = EnumSingleton.INSTANCE;
        singleton.doSomething();
        singleton.setData("Hello");
        System.out.println(singleton.getData());
    }
}

// Runtime 类是典型的单例模式
public class RuntimeDemo {
    public static void main(String[] args) {
        // 获取 Runtime 实例
        Runtime runtime = Runtime.getRuntime();

        // 使用单例实例
        System.out.println("处理器数量: " + runtime.availableProcessors());
        System.out.println("最大内存: " + runtime.maxMemory() / 1024 / 1024 + " MB");
    }
}

// 通过反射可以创建新的实例，破坏单例
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton newSingleton = constructor.newInstance();

// 解决方案：使用枚举单例
public enum EnumSingleton {
    INSTANCE;
}

// 序列化和反序列化会创建新实例
// 解决方案：添加 readResolve() 方法
public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static volatile Singleton instance;

    private Singleton() {}

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

    // 防止反序列化创建新实例
    protected Object readResolve() {
        return getInstance();
    }
}

// 解决方案：提供重置方法，仅用于测试
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

    // 仅用于测试
    static void resetInstance() {
        instance = null;
    }
}