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("单例模式禁止克隆");
    }
}