【JavaEE】Java设计模式-单例模式(饿汉式与懒汉式)

目录

1.设计模式是啥?

2.单例模式

2.1什么是单例模式 

2.2饿汉模式 

2.3懒汉模式 

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

3.1.线程安全方面

3.2.资源加载和性能

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


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();
}

注意:

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

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

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

3.1.线程安全方面

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

3.2.资源加载和性能

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

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

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

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

  1.  抢占式执行
  2. 修改操作,不是原子性的

  3. 内存可见性,引发的线程不安全

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

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

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

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

【JavaEE】Java设计模式-单例模式(饿汉式与懒汉式)_第1张图片

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

这样说不是很只管,我们画图来说明(这里的例子仅代表一种情况):

【JavaEE】Java设计模式-单例模式(饿汉式与懒汉式)_第2张图片

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

【JavaEE】Java设计模式-单例模式(饿汉式与懒汉式)_第3张图片

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

真的就完成了吗?

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

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

【JavaEE】Java设计模式-单例模式(饿汉式与懒汉式)_第4张图片

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

如果有多个线程都调用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() {

    }
}

 

 写在最后:

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

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

你可能感兴趣的:(JavaEE,java,单例模式,设计模式)