单例模式

目录

一、核心作用

二、优点

三、各种版本的单例模式

四、单例模式几种不同实现方式

第一种（懒汉模式，线程不安全）

 第二种（懒汉模式，线程安全）

  第三种（饿汉模式）

第四种（饿汉模式，变种）

    第五种（静态内部类）

第六种（枚举）

第七种（双重校验锁） 

 

一、核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

二、优点

单例模式只生成一个实例，减少了系统性能开销

三、各种版本的单例模式

实现单例模式的基本规则：
（1）构造器私有化，不让外部创建对象
（2）提供外部调用的对象的方法

1、饿汉式

饿汉式的特点是“饿”，即类加载时便创建对象。

    //饿汉式：类初始化时立即加载
    private static SingletonDome01 singleton = new SingletonDome01();
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome01(){
    }
    //提供访问方法，每次访问返回的都是同一个对象
    public static SingletonDome01 getSingleton(){
        return singleton;
    }

特点：
线程安全的：虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因。
问题：
可能造成资源浪费：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！

2、懒汉式

懒汉式的特点是“懒”，即类加载的时候不创建对象，在第一次调用访问方法时创建，再次调用时直接调用。

    //懒汉式：类初始化时不立即加载
    private static SingletonDome02 singleton;
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome02(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
    public static synchronized SingletonDome02 getSingleton(){
        if(singleton == null){
            singleton = new SingletonDome02();
        }
        return singleton;
    }

问题：
每次调用getInstance()方法都要同步，并发效率较低。在不加synchronized时，假设A、B同时访问，A创建了对象，但是由于B也是null，也创建了一个对象，导致创建了多个对象，不符合单例的原则。

3、双重检测锁

因为饿汉式会让整个方法进行等待，效率低。因此将同步内容下方到if内部，提高了执行的效率。不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。

    //懒汉式：类初始化时不立即加载
    private static SingletonDome03 singleton;
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome03(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回
    public static SingletonDome03 getSingleton(){
        if (singleton == null) {
            SingletonDome03 sc;//第一次访问时定义一个对象
            synchronized (SingletonDome03.class) {
                sc = singleton;
                if (sc == null) {
                    synchronized (SingletonDome03.class) {
                        if(sc == null) {
                            sc = new SingletonDome03();
                        }
                    }
                    singleton = sc;
                }
            }
        }
        return singleton;
    }

由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。

4、静态内部类实现

    //静态内部类不会立即加载，只有真正调用时才会加载
    private static class SingletonClass{
        private static final SingletonDome04 singleton = new SingletonDome04();
    }
    //构造器私有化，外部用户不能够创建对象
    private SingletonDome04(){
    }
    //提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
    public static synchronized SingletonDome04 getSingleton(){
        return SingletonClass.singleton;
    }

说明：
（1）加载外部类时不会直接创建对象；
（2）只有在调用访问方法时才会加载静态内部类去创建对象，同时加载一次类保证了线程安全。singleton是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
（3）兼备了并发高效调用和延迟加载的优势！

5、问题（针对以上四种方式）

（1）反射破解

        SingletonDome02 s1 = SingletonDome02.getSingleton();
        SingletonDome02 s2 = SingletonDome02.getSingleton();
        System.out.println(s1);
        System.out.println(s2);

        System.out.println();

        Class clazz = (Class) Class.forName("pri.xiaowd.singleton.SingletonDome02");
        Constructor c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true);//忽略权限
        SingletonDome02 s3 = c.newInstance();//构造对象
        SingletonDome02 s4 = c.newInstance();//构造对象
        System.out.println(s3);
        System.out.println(s4);

由此可见，利用反射破解了单例模式。

单例破解

通过在私有化的构造方法中抛异常的方法可以解决。如果对象已经创建了，则报错。

    private SingletonDome02(){
        if(singleton != null){
            throw new RuntimeException();
        }
    }

（2）反序列化破解
前提条件是SingletonDome02类实现了Serializable接口。

        //通过反序列化破解单例
        FileOutputStream fos = new FileOutputStream("d:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();

        ObjectInputStream ios = new ObjectInputStream(new FileInputStream("d:/a.txt"));
        SingletonDome02 s3 = (SingletonDome02) ios.readObject();
        System.out.println(s3);

反序列化破解单例

解决办法：在SingletonDome02类中定义一个方法.反序列化时会自动调用。

    //反序列化时如果定义了readResolve则直接返回此对象，不需要再创建
    private Object readResolve(){
        return singleton;
    }

6、枚举实现

    //这个枚举元素本身就是单例
    SINGLETON;
    
    //自己想要的操作
    public static void getSingleton() {
        
    }

优点：
– 实现简单。
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞。
缺点：
– 无延迟加载。

System.out.println(SingletonDome05.SINGLETON == SingletonDome05.SINGLETON);

返回true。

7、比较

常见的五种单例模式实现方式
– 主要：
• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式（线程安全，调用效率高。 但是，可以延时加载)
• 枚举式（线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化漏洞！)

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

四、单例模式几种不同实现方式

   单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

第一种（懒汉模式，线程不安全）

public class SingletonDemo1 {
    private static SingletonDemo1 instance;
    private SingletonDemo1(){}
    public static SingletonDemo1 getInstance(){
        if (instance == null) {
            instance = new SingletonDemo1();
        }
        return instance;
    }
}

 第二种（懒汉模式，线程安全）

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

  第三种（饿汉模式）

public class SingletonDemo3 {
    private static SingletonDemo3 instance = new SingletonDemo3();
    private SingletonDemo3(){}
    public static SingletonDemo3 getInstance(){
        return instance;
    }
}

第四种（饿汉模式，变种）

public class SingletonDemo4 {
    private static SingletonDemo4 instance = null;
    static{
        instance = new SingletonDemo4();
    }
    private SingletonDemo4(){}
    public static SingletonDemo4 getInstance(){
        return instance;
    }
}

    第五种（静态内部类）

public class SingletonDemo5 {
    private static class SingletonHolder{
        private static final SingletonDemo5 instance = new SingletonDemo5();
    }
    private SingletonDemo5(){}
    public static final SingletonDemo5 getInsatance(){
        return SingletonHolder.instance;
    }
}

第六种（枚举）

public class SingletonDemo6 {
 
    private SingletonDemo6() {}
 
    public static SingletonDemo6 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }
 
    private static enum Singleton {
        INSTANCE;
 
        private SingletonDemo6 singleton;
 
        private Singleton() {
            singleton = new SingletonDemo6();
        }
 
        public SingletonDemo6 getInstance() {
            return singleton;
        }
    }
}

第七种（双重校验锁） 

public class SingletonDemo7 {
    private volatile static SingletonDemo7 singletonDemo7;
    private SingletonDemo7(){}
    public static SingletonDemo7 getSingletonDemo7(){
        if (singletonDemo7 == null) {
            synchronized (SingletonDemo7.class) {
                if (singletonDemo7 == null) {
                    singletonDemo7 = new SingletonDemo7();
                }
            }
        }
        return singletonDemo7;
    }
}

 
 ———————————————— 
版权声明：本文为CSDN博主「鵬程萬裡」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_19309473/article/details/90216190

 

 

 

---

链接：https://www.jianshu.com/p/397210564b2e

 

---

来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。