java面试常见模式问题---单例模式

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对象一直占用着这段内存。

懒汉与饿汉式如何选择？

• 如果对象内存占用不大，且创建不复杂，直接使用饿汉的方式即可。

• 其他情况均采用懒汉方式(优选)。

来源：https://csp1999.blog.csdn.net/article/details/117590881#comments_16903610