【JavaEE】Java设计模式-单例模式（饿汉式与懒汉式）

爱吃大白菜　　

已于 2023-03-26 13:46:46 修改

阅读量1.4k

点赞数 7

分类专栏： JavaEE 文章标签： java 单例模式设计模式

于 2023-03-25 21:04:15 首次发布

本文链接：https://blog.csdn.net/qq_65228171/article/details/129771320

版权

JavaEE 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

1.设计模式是啥？

设计模式是前人经过总结，通过对不同应用场景应该运用何种方法解决问题的模式。我们可以将它看成NBA中的战术（例如：电梯门战术），在应对不同的队伍时，需要运用不同的战术，针对不一样的队伍用不一样的战术才能更高效的得分，这就相当于对不同的问题有固定的模板免得去思考，可以直接去使用。故可认为：它是解决待定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以重复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。

2.单例模式

2.1什么是单例模式

这个就看字面意思就很好理解，就是只能有一个例子，也就是该类只能new一个对象。

官方的说就是：这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

目前单例模式有两种：1.饿汉式 2.懒汉式

如何实现单例模式呢？我们就从者两个模式的具体实现来说明吧！

2.2饿汉模式

饿汉式单例模式实现步骤：

1.将构造器私有化

解释：防止用户构造新对象

2.在类中创建好一个对象

解释：因为我们把构造器进行了私有化操作，但我们单例模式中需要有个对象，因此我们需要在类中实例化好一个对象。

3.创建一个方法，或者类中创建好的对象

解释：因为我们外部不能创建对象，但是我们类中有创建好的对象，因此我们需要一个方法来将对象给取出来。

代码实现：

class Singleton {
    private static Singleton instance=new Singleton();
    public static Singleton getS() {
        return  instance;
    }

    private  Singleton(){};
}
public class testDemo1 {
    public static void main(String[] args) {
        Singleton singleton=Singleton.getS();
    }
}

注意：

观察代码，有几个细节需要注意；因为用户不可以创建对象，因此我们需要在类中创建好对象，不能创建对象，就意味着我们不能通过对象引用类中的成员方法与成员变量，即在类中new对象时和获得new好的对象时需要用静态成员变量和静态成员方法，通过类名来访问。

2.3懒汉模式

懒汉式单例模式实现步骤：

1.将构造器私有化

解释：防止用户构造新对象

2.在类中创建好一个对象

解释：因为我们把构造器进行了私有化操作，但我们单例模式中需要有个对象，因此我们需要在类中实例化好一个对象。

3.创建一个方法，或者类中创建好的对象

解释：因为我们外部不能创建对象，但是我们类中有创建好的对象，因此我们需要一个方法来将对象给取出来。

class  SingleLazy{
    private static SingleLazy instance=null;
    public static SingleLazy getInstance() {
        if(instance==null) {
            instance=new SingleLazy();
        }
        return instance;
    }
    private SingleLazy() {
        
    }
}
public class testDemo2 {
    SingleLazy singleLazy=SingleLazy.getInstance();
}

注意：

与饿汉模式不同之处时，懒汉模式只有在调用到这个对象时，对象才得以创建，在没有调用之前，创建出来的对象时null，懒汉模式要比饿汉模式节省一些不必要的资源。

3.懒汉模式与饿汉模式的区别

3.1.线程安全方面

饿汉式天生就是线程安全的，因为饿汉模式当中仅仅只有读操作，可以直接用于多线程而不会出现问题，懒汉式本身是非线程安全的，懒汉模式线程不安全是因为他在创造对象时会产生指令重排序。

3.2.资源加载和性能

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟。

4.如何保证懒汉模式的线程安全

首先我们要了解什么是线程不安全：

抢占式执行

修改操作，不是原子性的

内存可见性，引发的线程不安全

指令重排序引发的线程不安全

多线程修改同一个变量引发的线程不完全

具体的上方具体解读可以参考这篇文章理解：【JavaEE】多线程的风险-线程安全

我们对标一下在懒汉模式中有几条是符合上方条件的

在懒汉模式getInstance()方法中，对instance对象即包括了读操作，也包括了写操作；在操作时，会发生指令重排序这对于多线程是不完全的。

这样说不是很只管，我们画图来说明（这里的例子仅代表一种情况）：

这种情况我们如何避免呢？很好整，不同的问题，我们就不同的方案来解决，这时的解决方法就是给代码加锁。

这样我们就可以阻止指令重排序，让写操作在同一个线程内完成了！

真的就完成了吗？

并非如此，试想：在instance初始化之前，还是instance初始化之后，都会导致阻塞，存在大量的锁竞争，因此导致程序运行速度减慢（哪有一本万利的生意🐣）。

因此对于防止过多的锁竞争，我们需要再次改进代码：再加入一个判断（虽然有两个相同的if判断，但是两个判断的初心不同）,判断instance是否初始化，如果已经初始化过了，就不需要再次加锁了。

还有一个问题没有解决就是内存可见性的问题。

如果有多个线程都调用getInstance()方法，就会有大量的读instance操作，我们知道对于访问内存与寄存器，访问寄存器的速度要比内存高几个数量级；因此，编译器就会自作主张优化掉访问内存的操作；即：将读内存的操作优化为读寄存器的操作。

为了保证内存可见性，我们需要将在创建instance对象的语句上加上volatile关键字，来保证内存可见性。

完整代码如下：

class  SingleLazy{
    private volatile static SingleLazy instance=null;
    //创建一个实例对象
    public static SingleLazy getInstance() {
        //判断是否需要加锁
        if(instance==null) {
            synchronized (SingleLazy.class) {
                //判断对象是否实例化
                if (instance == null) {
                    instance = new SingleLazy();
                }
            }
        }
        return instance;
    }
    private SingleLazy() {

    }
}

写在最后：

以上就是本文全部内容，如果对你有所帮助，希望能留下你的点赞+关注，我会更加努力的更新内容！非常感谢🧡🧡🧡

若本篇文章有错误的地方，欢迎大佬们指正！