Java 中的单例类(Singleton)应用场景分析

public class EagerSingleton {
    // 类加载时就创建实例
    private static final EagerSingleton instance = new EagerSingleton();
    // 私有构造器
    private EagerSingleton() {
        // 防止反射攻击
        if (instance != null) {
            throw new RuntimeException("单例模式禁止反射创建实例");
        }
    }
    // 全局访问点
    public static EagerSingleton getInstance() {
        return instance;
    }
    public void showMessage() {
        System.out.println("饿汉式单例");
    }
}

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    // 线程不安全版本
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class ThreadSafeSingleton {
    private static volatile ThreadSafeSingleton instance;
    private ThreadSafeSingleton() {}
    // 方法同步（性能较差）
    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

public class DoubleCheckedSingleton {
    // 使用 volatile 保证可见性和禁止指令重排序
    private static volatile DoubleCheckedSingleton instance;
    private DoubleCheckedSingleton() {}
    public static DoubleCheckedSingleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (DoubleCheckedSingleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new DoubleCheckedSingleton();
                }
            }
        }
        return instance;
    }
}

public class InnerClassSingleton {
    private InnerClassSingleton() {
        // 防止反射攻击
        if (SingletonHolder.INSTANCE != null) {
            throw new RuntimeException("单例模式禁止反射创建实例");
        }
    }
    // 静态内部类在第一次被引用时才会加载
    private static class SingletonHolder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }
    public static InnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    public void showMessage() {
        System.out.println("静态内部类单例");
    }
}

public enum EnumSingleton {
    INSTANCE;
    public void showMessage() {
        System.out.println("枚举单例");
    }
    // 可以添加其他方法
    public void doSomething() {
        System.out.println("执行某些操作");
    }
}
// 使用方式
EnumSingleton.INSTANCE.showMessage();

// 1. 配置管理器
public class ConfigurationManager {
    private static class Holder {
        static final ConfigurationManager INSTANCE = new ConfigurationManager();
    }
    private Properties config;
    private ConfigurationManager() {
        // 加载配置文件
        config = new Properties();
        try {
            config.load(getClass().getResourceAsStream("/config.properties"));
        } catch (IOException e) {
            throw new RuntimeException("加载配置文件失败", e);
        }
    }
    public static ConfigurationManager getInstance() {
        return Holder.INSTANCE;
    }
    public String getProperty(String key) {
        return config.getProperty(key);
    }
}
// 2. 数据库连接池
public class DatabaseConnectionPool {
    private static final DatabaseConnectionPool instance = new DatabaseConnectionPool();
    private List<Connection> connections;
    private DatabaseConnectionPool() {
        // 初始化连接池
        connections = new ArrayList<>();
        // ... 创建数据库连接
    }
    public static DatabaseConnectionPool getInstance() {
        return instance;
    }
    public Connection getConnection() {
        // 从连接池获取连接
        return connections.isEmpty() ? null : connections.remove(0);
    }
    public void releaseConnection(Connection conn) {
        connections.add(conn);
    }
}
// 3. 日志记录器
public class Logger {
    private static volatile Logger instance;
    private Logger() {
        // 初始化日志系统
    }
    public static Logger getInstance() {
        if (instance == null) {
            synchronized (Logger.class) {
                if (instance == null) {
                    instance = new Logger();
                }
            }
        }
        return instance;
    }
    public void log(String message) {
        System.out.println("[LOG] " + new Date() + ": " + message);
    }
}

public class SerializableSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static SerializableSingleton instance = new SerializableSingleton();
    private SerializableSingleton() {}
    public static SerializableSingleton getInstance() {
        return instance;
    }
    // 防止反序列化创建新实例
    protected Object readResolve() {
        return getInstance();
    }
}

public class ReflectionSafeSingleton {
    private static ReflectionSafeSingleton instance;
    private static boolean initialized = false;
    private ReflectionSafeSingleton() {
        synchronized (ReflectionSafeSingleton.class) {
            if (initialized) {
                throw new RuntimeException("单例模式禁止反射创建实例");
            }
            initialized = true;
        }
    }
    public static ReflectionSafeSingleton getInstance() {
        if (instance == null) {
            synchronized (ReflectionSafeSingleton.class) {
                if (instance == null) {
                    instance = new ReflectionSafeSingleton();
                }
            }
        }
        return instance;
    }
}

public class CloneSafeSingleton implements Cloneable {
    private static final CloneSafeSingleton instance = new CloneSafeSingleton();
    private CloneSafeSingleton() {}
    public static CloneSafeSingleton getInstance() {
        return instance;
    }
    // 防止克隆
    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException("单例模式禁止克隆");
    }
}