多线程-单例模式 - Double Check Lock - Volatile

最新推荐文章于 2024-04-12 10:00:00 发布

Shacoray

最新推荐文章于 2024-04-12 10:00:00 发布

阅读量484

点赞数

分类专栏： java 文章标签： java 多线程设计模式单例模式 volatile

本文链接：https://blog.csdn.net/jllion/article/details/115655684

版权

java 专栏收录该内容

62 篇文章 1 订阅

订阅专栏

单例模式（Singleton）：

保证一个类在程序中仅有一个实例，并提供一个访问该实例的全局访问点。

单例模式的实现-饿汉模式：

设计思想：在类加载时就创建一个不可变的静态的单例对象。（如果该对象不被使用，则浪费了堆空间的资源）

//问题1： 为什么加final
//答：可以防止子类通过操作生成父类的对象,不适当的覆盖父类的方法，从而破坏单例
//问题2：如果实现了序列化接口，还要做什么来防止反序列化破坏单例、
//答：通过在readResolve方法中，返回INSTANCE来防止反序列化破坏单例
public final class Singleton implements Serializable {
    //问题3：为什么设置构造方法为私有?是否能防止反射创建新的实例？
    //回答：1.防止通过new 构造器的方式，创建单例类的对象。设置为私有不能防止反射创建单例
    private Singleton(){
    }
    //问题4：这样初始化是否能保证单例对象创建时的线程安全?
    //回答：可以的，线程是安全的，静态变量的初始化操作是在类加载中完成的。
    private static final Singleton INSTANCE = new Singleton();
    //问题5：为什么提供静态方法而不是将INSTANCE设置为public,说出你知道的理由
    //回答：1.提供更好的封装性，2.也便于修改为懒汉模式 3.也可以提供泛型的支持，4.还能再获取单例对象前做一些自定义的逻辑
    public static Singleton getInstance(){
        return INSTANCE;
    }

    public Object readResolve(){
        return INSTANCE;
    }
}

关于懒汉模式的解析：

问题1：为什么要用final关键字修饰单例类

答：这样做可以防止子类继承单例类后，不适当的覆盖了父类的方法，最后导致破坏了单例

问题2：如果单例类实现了Serializable 序列化接口，如何防止反序列化破坏单例

答：通过在readResolve方法中，返回INSTANCE来防止反序列化来破坏单例

问题:3：为什么要将单例类的构造方法私有化？将构造方法私有化能否防止反射创建新的实例

答：将单例类的构造方法私有化是为了防止通过new 构造器的方式在外部创建单例类的对象。将单例类的构造方法私有化并不能防止反射创建新的实例

问题4：通过 static final 创建静态的不可变变量是否能单例对象创建时的线程安全。

答：可以的，静态变量的初始化操作是在类加载中完成的。

问题5：为什么提供静态方法而不是将INTANCE设置为public

答：1.提供更好的封装性；2.便于扩展修改为懒汉模式；3.也可以提供泛型的支持；4.便于在单例对象创建是做一些其他的自定义操作

单例模式-懒汉模式：

设计思想，在类加载时先不创建单例对象，等到需要使用的时候创建单例对象（节省资源）。

实现1（存在线程安全问题-并不能保证单例对象只有一个实例）：

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/13 9:43
 */
public class MySingleton {

    private static MySingleton instance= null;

    private MySingleton() {
    }


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

分析：

当程序中没有MySingleton对象实例，多线程同时调用getInstance1()方法时，可能会创建多个实例。

实现2（线程安全，也保证了程序中只有一个单例对象实例，但是性能较差）：

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/13 9:43
 */
public class MySingleton {

    private static MySingleton instance= null;

    private MySingleton() {
    }


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

分析：

使用该方式创建的单例对象，第一次使用单例，多线程同时访问时，只有一个线程能获取到锁，其他线程进入阻塞。等到获取到锁的线程创建完了instance对象，其他线程进去同步代码块时判断instance是否为null。

此时的instance 已经被创建了，所以其他线程可以直接返回instance的单例对象实例。

但是该方法存在问题，第一次使用单例对象后的每次调用所有的线程都会去尝试获取锁，并且进入同步代码块做判断，非常消耗性能。

实现3：双检锁 double check locking(dcl) 性能上优化，在第一次使用后，后续的调用不需要去获取锁。

存在的问题，由于存在指令重排序，会导致线程获取到了“不为空，但是未调用构造函数的对象”。

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/13 9:43
 */
public class MySingleton {

    private static MySingleton instance= null;

    private MySingleton() {
    }


    /**
     * double checked locking (dcl) 存在问题
     * @return
     */
    public final static MySingleton getInstance2(){
        //先判断是否非空
        if(instance == null){
            //加锁，只有获取到锁的线程才能创建
            synchronized (MySingleton.class){
                //第一创建的时候，多个线程竞争锁，未获取到锁的线程进入阻塞，当其他线程
                if(instance ==null){
                    instance = new MySingleton();
                }
            }
        }
        return instance;
    }

}

分析：

该方法在第一次使用单例对象时，多线程同时访问，竞争获取锁，创建对象。后续访问则不获取尝试获取锁，从而提高性能

问题：

由于synchronized并不能保证内部代码的指令重排序，所以可能导致

反编译后的字节码

//获取instance变量
0 getstatic #2 <MySingleton.instance>

//判断instance变量是否不为空，如果为空则跳转到37 行 返回对象
3 ifnonnull 37 (+34)

6 ldc #3 <MySingleton>
8 dup
9 astore_0

//获取同步监视器，进入同步代码块
10 monitorenter
11 getstatic #2 <MySingleton.instance>
14 ifnonnull 27 (+13)

//instance为空 创建对象
17 new #3 <MySingleton>

//复制引用
20 dup

//调用构造方法创建对象
21 invokespecial #4 <MySingleton.<init>>

//将引用复制给静态变量
24 putstatic #2 <MySingleton.instance>
27 aload_0
28 monitorexit
29 goto 37 (+8)
32 astore_1
33 aload_0
34 monitorexit
35 aload_1
36 athrow
37 getstatic #2 <MySingleton.instance>
40 areturn

其中：

17表示创建对象，将对象引用入栈//new Singleton

20表示复制一份对象引用

21表示利用一个对象引用，调用构造方法

24表示利用一个引用，赋值给static INSTANCE

也许jvm会优化为：先执行24将引用复制给staic INSTANCE，在执行21调用对象引用的构造方法，

此时如果两个线程来访问,t1线程先调用了24:putstatic将instance赋值了，此时t2线程访问判断instance不为空，则正常返回了instance 的正常使用，但这个instance的实例还没有调用构造方法

导致t2线程使用异常

实现4：对静态变量加上 volatile修饰，防止指令重排序

/**
 * @author jiangl
 * @version 1.0
 * @date 2021/4/13 9:43
 */
public class MySingleton {

    /**
     * 加入volatile 防止指令重排序
     */
    private volatile static MySingleton instance= null;

    private MySingleton() {
    }

    /**
     * double checked locking (dcl)
     * @return
     */
    public final static MySingleton getInstance(){
        //先判断是否非空
        if(instance != null){
            return instance;
        }
        //加锁，只有获取到锁的线程才能创建
        synchronized (MySingleton.class){
            //第一创建的时候，多个线程竞争锁，未获取到锁的线程进入阻塞，当其他线程
            if(instance ==null){
                instance = new MySingleton();
            }
            return instance;
        }

    }


}