设计模式之单例模式

最新推荐文章于 2024-10-23 22:17:36 发布

hap0728

最新推荐文章于 2024-10-23 22:17:36 发布

阅读量109

点赞数 1

CC 4.0 BY-SA版权

分类专栏：设计模式

本文链接：https://blog.youkuaiyun.com/qq_42643690/article/details/102480528

设计模式专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了单例模式的各种实现方式，包括饿汉式、懒汉式、双重检测锁、静态内部类及枚举式。分析了每种方式的优缺点，如资源利用、线程安全、延迟加载等特性，并提供了选用建议。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

饿汉式


/**
 * 饿汉式（单例模式）
 * 如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！
 */
public class SingletonDemo1 {

    private static  SingletonDemo1 testDemo1=new SingletonDemo1();

    //构造器私有化
    private SingletonDemo1(){}

    //static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。
    // 虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字
    //提供静态方法直接获取对象
    public static synchronized SingletonDemo1 getInstance(){
        return testDemo1;
    }
}

懒汉式

/**
 * 懒汉式（单例模式）
 */
public class SingletonDemo2 {

    private static SingletonDemo2 singletonDemo2;

    private SingletonDemo2(){

    }

    //资源利用率高了。但是，每次调用getInstance()方法都要同步，并发效率较低。
    public static synchronized SingletonDemo2 getInstance() {
        if (singletonDemo2 == null) {
            singletonDemo2=new SingletonDemo2();
        }
        return singletonDemo2;
    }
}

双重检测锁

/**
 * 双重检测锁实现
 * 这个模式将同步内容下方到if内部，提高了执行的效率
 * 不必每次获取对象时都进行同步，只有第一次才同步
 * 创建了以后就没必要了。
 * <p>
 * 由于编译器优化原因和JVM底层内部模型原因，
 * 偶尔会出问题。不建议使用。
 */
public class SingletonDemo3 {

    private static SingletonDemo3 singletonDemo3 = null;

    public static SingletonDemo3 getInstance() {
        if (singletonDemo3 == null) {
            SingletonDemo3 newSingleton;
            synchronized (SingletonDemo3.class) {
                newSingleton = singletonDemo3;
                if (newSingleton == null) {
                    synchronized (SingletonDemo3.class) {
                        newSingleton = new SingletonDemo3();
                    }
                    singletonDemo3 = newSingleton;
                }
            }
        }
        return singletonDemo3;

    }
}

静态内部类

/**
 *  静态内部类实现方式(也是一种懒加载方式)
 *
 *  – 外部类没有static属性，则不会像饿汉式那样立即加载对象。
 * – 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。 instance是static final
 * 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
 * – 兼备了并发高效调用和延迟加载的优势！
 */
public class SingletonDemo4 {

    private SingletonDemo4() {

    }

    private static class getSingletonDemo4 {
        private static final SingletonDemo4 singletonDemo4 = new SingletonDemo4();
    }

    public static SingletonDemo4 getInstance() {
        return getSingletonDemo4.singletonDemo4;
    }

}

对上面方法的优化

/**
 * 单例模式
 *  反射可以破解上面几种(不包含枚举式)实现方式！ （可以在构造方法中手动抛出异常控制）
 * – 反序列化可以破解上面几种((不包含枚举式))实现方式！
 * • 可以通过定义readResolve()防止获得不同对象。
 * – 反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），
 * 定义返回哪个对象
 */
public class SingletonDemo5 implements Serializable {

    private static SingletonDemo5 singletonDemo5;

    private SingletonDemo5() throws Exception{
        // 通过手动抛出异常，避免通过反射创建多个单例对象！
        if(singletonDemo5!=null){
            throw new Exception("只能实例化一个对象");
        }
    }

    public static synchronized SingletonDemo5 getInstance() throws Exception{
        if(singletonDemo5==null){
            singletonDemo5=new SingletonDemo5();
        }
        return singletonDemo5;
    }

    //反序列化时，如果对象所在类定义了readResolve() ，（实际是一种回调），定义返回哪个对象。
    private Object readResolve() throws ObjectStreamException {
        return singletonDemo5;
    }


}

枚举

/**
 * 单例模式之使用枚举实现单例模式
 * 优点：
 * – 实现简单
 * – 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！
 * • 缺点：
 * – 无延迟加载
 */
public enum  SingletonDemo6 {
    // 定义一个枚举的元素，它就代表了Singleton
    INSTANCE;

    //单例可以有自己的操作
    public void toDoSt(){

    }
}

如何选用?
– 单例对象占用资源少，不需要延时加载：枚举式好于饿汉式
– 单例对象占用资源大，需要延时加载：静态内部类式好于懒汉式