Java实习生面试常问设计模式——单例模式

Posted 兴趣使然的草帽路飞

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java实习生面试常问设计模式——单例模式相关的知识,希望对你有一定的参考价值。

  • 临近秋招,备战暑期实习,祝大家每天进步亿点点!Day16
  • 本篇总结的是 单例设计模式,后续会每日更新~

在这里插入图片描述


1、简介

  • 单例模式使⽤场景:
    • 业务系统全局只需要⼀个对象实例,⽐如发号器、 redis 连接对象等。
    • Spring IOC容器中的 Bean 默认就是单例。
    • Spring Boot 中的 Controller、Service、Dao 层中通过 @Autowire的依赖注⼊对象默认都是单例的。
  • 单例模式分类:
    • 懒汉:就是所谓的懒加载,延迟创建对象,需要用的时候再创建对象。
    • 饿汉:与懒汉相反,提前创建对象。
  • 单例模式实现步骤:
    • 私有化构造函数
    • 提供获取单例的⽅法

2、单例模式——懒汉式

单例模式——懒汉式有以下⼏种实现⽅式:

/**
 * @Auther: csp1999
 * @Date: 2020/11/06/20:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     * 
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功!");
    }

    /**
     * 方式一:
     * <p>
     * 对外暴露一个方法获取该类的对象
     * <p>
     * 缺点:线程不安全,多线程下存在安全问题
     *
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            /**
             * 线程安全问题:
             * 当某一时刻,两个或多个线程同时判断到instance == null成立的时候
             * 这些线程同时进入该if判断内部执行实例化
             * 则会新建出不止一个SingletonLazy实例
             */
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }

    /**
     * 方式二:
     * 通过加synchronized锁 保证线程安全
     *
     * 采用synchronized 对方法加锁有很大的性能开销
     * 因为当getInstance2()内部逻辑比较复杂的时候,在高并发条件下
     * 没获取到加锁方法执行权的线程,都得等到这个方法内的复杂逻辑执行完后才能执行,等待浪费时间,效率比较低
     *
     * @return
     */
    public static synchronized SingletonLazy getInstance2() {
        if (instance == null) {// 实例为null时候才创建
            // 方法上加synchronized锁后可以保证线程安全
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }

    /**
     * 方式三:
     * 在getInstance3()方法内,针对局部需要加锁的代码块加锁,而不是给整个方法加锁
     *
     * 也存在缺陷:
     * @return
     */
    public static SingletonLazy getInstance3() {
        if (instance == null) {// 实例为null时候才创建
            // 局部加锁后可以保证线程安全,效率较高
            // 缺陷:假设线程A和线程B
            synchronized (SingletonLazy.class){
                // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
                // 当A线程执行完毕后,B再获得执行权,这时候还是可以实例化该对象
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
        return instance;
    }
}

单例模式:懒汉实现 + 双重检查锁定 + 内存模型

对于上面方式三存在的缺陷,我们可以使用双重检查锁定的方式对其进行改进:

/**
 * 方式三改进版本:
 * 在getInstance3()方法内,针对局部需要加锁的代码块加锁,而不是给整个方法加锁
 *
 * DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能
 *
 * 这是否安全? instance = new SingletonLazy(); 并不是原子性操作
 * jvm中 instance实例化内存模型流程如下:
 * 1.分配空间给对象
 * 2.在空间内创建对象
 * 3.将对象赋值给instance引用
 *
 * 假如出现如下顺序错乱的情况:
 * 线程的执行顺序为:1 -> 3 -> 2, 那么这时候会把值写回主内存
 * 则,其他线程就会读取到instance的最新值,但是这个是不完全的对象
 * (指令重排现象)
 *
 * @return
 */
public static SingletonLazy getInstance3plus() {
    if (instance == null) {// 实例为null时候才创建
        // 局部加锁后可以保证线程安全,效率较高
        // 假设线程A和线程B 
        synchronized (SingletonLazy.class){// 第一重检查
            // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
            // 当A线程执行完毕后,B再获得执行权,这时候再判断instance == null是否成立
            // 如果不成立,B线程无法 实例化SingletonLazy
            if (instance == null){// 第二重检查
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
    }
    return instance;
}

再次升级方式三,来解决内存模型中的指令重排问题:

// 添加volatile 关键字,禁止实例化对象时,内存模型中出现指令重排现象
private static volatile SingletonLazy instance;

/**
 * 方式三再次升级版本:
 * 在getInstance3()方法内,针对局部需要加锁的代码块加锁,而不是给整个方法加锁
 *
 * DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能
 *
 * 解决指令重排问题——禁止指令重排
 * @return
 */
public static SingletonLazy getInstance3plusplus() {
    if (instance == null) {// 实例为null时候才创建
        // 局部加锁后可以保证线程安全,效率较高
        // 假设线程A和线程B
        synchronized (SingletonLazy.class){// 第一重检查
            // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
            // 当A线程执行完毕后,B再获得执行权,这时候再判断instance == null是否成立
            // 如果不成立,B线程无法 实例化SingletonLazy
            if (instance == null){// 第二重检查
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
    }
    return instance;
}

单例模式——懒汉式调用:

@Test
public void testSingletonLazy(){
    SingletonLazy.getInstance().process();
}

3、单例模式——饿汉式

/**
 * @Auther: csp1999
 * @Date: 2020/11/06/21:39
 * @Description: 单例设计模式-饿汉式
 */
public class SingletonHungry {

    // 当类加载的时候就直接实例化对象
    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry(){}

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功!");
    }

    public static SingletonHungry getInstance(){
        return instance;// 当类加载的时候就直接实例化对象
    }
}

单例模式——饿汉式调用:

@Test
public void testSingletonHungry(){
    SingletonHungry.getInstance().process();
}

饿汉式单例模式,当类加载的时候就直接实例化对象,因此不需要考虑线程安全问题

  • 优点:实现简单,不需要考虑线程安全问题。
  • 缺点:不管有没有使用该对象实例,instance对象一直占用着这段内存。

懒汉与饿汉式如何选择

  • 如果对象内存占用不大,且创建不复杂,直接使用饿汉的方式即可。
  • 其他情况均采用懒汉方式(优选)。

总结的面试题也挺费时间的,文章会不定时更新,有时候一天多更新几篇,如果帮助您复习巩固了知识点,还请三连支持一下,后续会亿点点的更新!

在这里插入图片描述


为了帮助更多小白从零进阶 Java 工程师,从CSDN官方那边搞来了一套 《Java 工程师学习成长知识图谱》,尺寸 870mm x 560mm,展开后有一张办公桌大小,也可以折叠成一本书的尺寸,有兴趣的小伙伴可以了解一下,当然,不管怎样博主的文章一直都是免费的~
在这里插入图片描述

以上是关于Java实习生面试常问设计模式——单例模式的主要内容,如果未能解决你的问题,请参考以下文章

Java岗大厂面试官常问的那些问题,面试突击版!

Java萌新面试常问设计模式——工厂模式

Java萌新面试常问设计模式——工厂模式

Java萌新面试常问设计模式——代理模式

Java萌新面试常问设计模式——代理模式

面试官常问的设计模式及常用框架中设计模式的使用