《javaEE篇》--单例模式详解

喝养乐多长不高

已于 2024-07-24 18:25:03 修改

阅读量1k

点赞数 25

分类专栏： JavaEE 文章标签： java-ee java 单例模式懒汉模式饿汉模式指令重排序

于 2024-07-24 11:28:02 首次发布

本文链接：https://blog.csdn.net/hyldzbg/article/details/140639244

版权

JavaEE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

单例模式

单例模式属于一种设计模式，设计模式就好比是一种固定代码套路类似于棋谱，是由前人总结并且记录下来我们可以直接使用的代码设计思路。

单例模式就是，在有些场景中希望一个类只能有一个对象，不能有多个，这时你可能会觉得，这还不简单，我保证自己只new一个对象不就好了，但是你能保证自己只new一个对象，但是你能保证别人不会new对象吗？又或者，你真的能确保自己只new一个对象吗？所以“我保证自己只new一个对象不就好了”，这只是一个君子协定，光靠人是非常不靠谱的，所以我们要依靠计算机来帮助我们实现这个协定。

//这一点在很多场景上都需要. 比如 JDBC 中的 DataSource 实例就只需要一个.

单例模式的实现方式可以分为两种，饿汉模式和懒汉模式

饿汉模式

具体实现方法

用static修饰，在类的内部创建一个现成的实例，让对象在在类加载时就被创建
提供一个方法当需要这个对象时就通过这个方法获得
用private修饰构造方法，这样外界就不能实例化这个类了

通过这三个方法就可以保证只有一个该类对象了

class Singleton{//创建时时机比较早(饿汉模式)
    //当类被加载时就会执行这里的创建实例操作
    private static Singleton instance = new Singleton();
    //后续需要这个对象，都通过这个方法获取
    public static Singleton getInstance(){
        return instance;
    }
    //私有构造方法
    private Singleton(){

    }
}
public class Demo17 {
    public static void main(String[] args) {
        //把构造方法设置为私有，之后就无法实例化这个对象了，这能通过刚刚创建的方法
        //Singleton singleton = new Singleton();
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        //这两个对象其实是一样的
        System.out.println(s1 == s2);
    }
}

通过运行结果我们可以验证，上述在main方法中创建的对象是同一个，也就是刚刚在类中创建的那一个对象

这种方法会在类加载时就把对象创建好，如果不使用就会造成资源浪费

懒汉模式

具体实现

用static修饰，只声明类型创建实际对象
私有构造方法
提供外界用来获得对象的方法，设定当第一次调用方法时才创建对象

class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)
    //只声明一个类型不创建实际对象
    private static SinngletonLazy instance = null;
    public static SinngletonLazy getInstance(){
        //如果是第一次调用，就创建实例对象，否则直接返回对象
            if(instance == null){
                instance = new SinngletonLazy();
            }
        return instance;
    }
    //私有构造方法
    private SinngletonLazy(){
    }
}

饿汉模式和懒汉模式的最大区别就是，饿汉模式在类加载时就创建了对象，懒汉模式在第一次调用方法时才创建对象，假如我们要打开一本电子书，饿汉模式是要把整本书都加载完成才可以看，而懒汉模式则是在翻页时才加载下一页，可想而知懒汉模式是更高效的。

懒汉模式(优化)

不过上述实现懒汉模式的方法只在单线程下才适用，如果是在多线程环境下会引起线程安全问题。

这里我来画图解释一下

如果当t1执行到①时，if判定为真，程序将要进到if语句内部，此时t2线程插了进来，由于t1线程还没创建出对象，所以t2线程的if语句也会判定为真，接着t2线程new了一个对象然后返回，最后又回到t1线程这边紧接着又new了一个对象，此时代码就出现问题了。

我们第一时间想到的方法就是直接给方法加上锁，这个方法确实可以解决问题，但是这样的话，代码的并发性就降低了，进而影响到代码的效率，所以我们要换种思路。

可以思考一下，我们的加锁操作只是再第一次创建对象时才需要，所以我们在加锁操作前再加一个if语句来判断当前是否需要加锁，这样就既实现了懒汉模式，又优化了代码的效率

class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)
    //只声明一个类型不创建实际对象
    private static SinngletonLazy instance = null;
    public static SinngletonLazy getInstance(){
        //如果是第一次调用，就加锁创建对象，否则直接返回对象
        if(instance == null) {//判断是否需要加锁
            synchronized (SinngletonLazy.class){
                if (instance == null) {//判断是否需要new对象
                    instance = new SinngletonLazy();
                }
            }
        }
        return instance;
    }
    //私有构造方法
    private SinngletonLazy(){
    }
}

用简洁的话总结一下就是，因为为了防止资源浪费，所以使用一个if条件判断是否需要创建对象，因为在多线程下会出现线程安全的问题，所以要加锁，又因为只需要再第一次创建对象时才需要加锁，所以为了提升效率，再加一层if判断当前是否需要加锁(这两个if本质上没有什么关系，只是刚好判断条件一样而已)

这种方法也叫做Double Check(双重检验) + Lock(加锁)

虽然当前的代码已经很完善了但是还是会有指令重排序的问题

指令重排序

指令重排序也是一种编译器的优化，是编译器为了提高效率，在保证代码逻辑顺序不变的情况下，改变代码的实际顺序。

实际上这里的new操作可以分成三个步骤

向内存申请空间
在刚刚申请的空间上构造对象
把刚刚申请的空间的地址付给instance

但是后面两个步骤对于编译器来说是可以颠倒的，按照123或者132来执行都是可以的，就看那种效率快，在单线程下是没有问题的但是在多线程下就会出现问题

假设有t1，t2线程，t1线程执行到new操作之后先执行1，3，此时编译器已经把刚刚申请的内存地址付给instance，Instance此时已经是一个非空的了，也就是说，此时instance指向一个还没有初始化的非法对象。但是这个时候还没有执行2操作，假如这时t2线程开始执行，判定第一个instance==Null，条件不成立(因为刚刚t1线程已经给instance赋值了)，t2线程就直接会返回instance对象。但是此时，t1还没有到内存上构造出对象，T2线程的代码可能就会访问instance里面的属性了，进而就会引起一些bug。

这里可能会有疑问了，刚刚不是给new操作加锁了吗？为什么还会再new操作时插入其他线程？这就是刚刚代码的缺陷之处，我们为了提高效率只是给new操作加锁了，但是此时t2线程只是执行到了第一个if条件，还没有涉及到任何锁操作，就更谈不上阻塞等待了。t2线程此时连第一个if条件都没有进去，就拿着一个还没有初始化的非法对象返回了。

解决方法

不过解决方法也很简单，使用volatile关键字修饰就可以了，volatile可以防止指令重排序，相当于告诉编译器，不要进行代码优化，让它按照本来的顺序执行

此外volatile还有一个作用：保证内存可见性，就是每一时刻线程读取到该变量的值都是内存中最新的那个值(线程每次操作该变量都需要先读取该变量)

最终代码展示：

class SinngletonLazy{//在第一次调用时创建对象(懒汉模式)
    //只声明一个类型不创建实际对象
    private static volatile SinngletonLazy instance = null;
    public static SinngletonLazy getInstance(){
        //如果是第一次调用，就加锁创建对象，否则直接返回对象
        if(instance == null) {//判断是否需要加锁
            synchronized (SinngletonLazy.class){
                if (instance == null) {//判断是否需要new对象
                    instance = new SinngletonLazy();
                }
            }
        }
        return instance;
    }
    //私有构造方法
    private SinngletonLazy(){
    }
}

总结

饿汉模式：在类加载时创建对象，通过方法直接返回该对象，不会出现并发安全问题

懒汉模式：在第一次需要对象是才会创建对象，但会有并发问题，建议使用Double Check(双重检验) + Lock(加锁) 可以很好的解决问题

为了在多线程环境下防止，疑问指令重排序而导致代码出现问题，要使用volatile修饰对象

以上就是博主对单例模式知识的分享，在之后的博客中会陆续分享有关线程的其他知识，如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主，也希望多多支持博主之后和博客！！🥰🥰

下一篇博客博主将分享有关阻塞队列等知识，还希望多多支持一下！！！😊

喝养乐多长不高

关注

25
点赞
踩
37

收藏

觉得还不错? 一键收藏
7
评论
《javaEE篇》--单例模式详解

饿汉模式：在类加载时创建对象，通过方法直接返回该对象，不会出现并发安全问题懒汉模式：在第一次需要对象是才会创建对象，但会有并发问题，建议使用Double Check(双重检验) + Lock(加锁)可以很好的解决问题为了在多线程环境下防止，疑问指令重排序而导致代码出现问题，要使用volatile修饰对象以上就是博主对线程知识的分享，在之后的博客中会陆续分享有关线程的其他知识，如果有不懂的或者有其他见解的欢迎在下方评论或者私信博主，也希望多多支持博主之后和博客！！🥰🥰下一篇博客博主将分享有关。
复制链接

扫一扫

专栏目录