Java 面试之单例模式

前言

单例模式是 23 种 GOF(设计模式) 中最简单的一种设计模式,也是最经典的一种设计模式。在 Java 面试中,可以说是必问的一个知识点了。接下来我们就来具体说一说。

面试官:对设计模式熟悉吗?你工作中用过哪些设计模式呢?

应聘者:工作常用的有单例模式,工厂模式,责任链模式,代理模式 ...

面试官:哦!既然你说到了单例模式,那你说说看什么是单例模式?为什么要用单例模式? 有几种单例模式?使用的时候要注意什么?

面试官一般情况下都是通过上面一段对话,切入到单例模式这个知识点的。

什么是单例模式?

简单来说,单列模式是为了保证某个对象在程序的生命周期内,在内存中只存在一个实例。即一个类只有一个对象。

为什么要用单例模式?

使用单例模式无非是为了提高代码的执行性能,我们可以从下面两点谈起:

  • 1.节省内存资源

  • 2.节省时间(分配对象的时间)

首先是节省内存资源,对于程序中一些大对象,这些对象占用内存较大,频繁创建不但内存开销增大,还会耗费很多内存分配的时间,另外,会触发频繁的 GC(垃圾回收),GC 又会增加时间开销,情况严重的,可能还会发生 Full GC, 导致程序主线程阻塞,这些都是不可容忍的。单列模式正是在这种情况下孕育而生的。

有几种单例模式?

通常情况下我们说 5 种就可以了,但是为了显示我们知识面宽泛,我们可以这样说:

应聘者:单例模式细分的话有 7 种,但是严格来讲只有五种。先说说细分的的七种:

第一种:懒汉,线程不安全

public class Singleton {  

  private static Singleton instance;  
  
  private Singleton (){}   
  
  public static Singleton getInstance() {  
  if (instance == null) {  
    instance = new Singleton();}  
  return instance;  
  }  
} 

这种写法是懒加载的写法,比较致命的是,在多线程情况下,会出现多次实例化 Singleton 对象。

第二种:懒汉,线程安全的

public class Singleton {
  private static Singleton instance;
  private Singleton (){}

  public static synchronized Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();}
    return instance;
  }
}

这种写法能够很好的运行在多线程的环境中,也具备懒汉加载的优势,但是,很遗憾的是,效率很低,99% 的情况下不需要同步。

第三种:饿汉式

public class Singleton {  

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

这种方式是基于 java 类加载机制避免了多线程同步的问题,不过正因为如此,实例在装载时就实例化,而且导致实例化的原因还有很多种,有时候,我们是不愿意将其实例化的。而且单例模式大多数实例化都是调用 getInstance() 方法,违背了懒加载的设计。

注意1:这里面试官可能还会问你:instance 什么时候被初始化?

instance 在类被加载的时候就会被初始化,说到类的加载,在 JVM 虚拟机规范中并没有强制性约束在什么具体时间加载类,但是关于类的初始化,虚拟机严格规定了有且只有 4 种情况,分别是遇到下面 4 条字节码指定时:

    1. new
    1. getStatic
    1. putStatic
    1. invokeStatic

遇到上面 4 种字节指定码时,若类没有进行过初始化,则需要先触发其初始化。

至于什么时候生成上述 4 条指令,分别对应下面场景:

  • 1.使用new关键字实例化对象 ==> 对应 new 指令;

  • 2.读取一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)==> 对应 getStatic 指令;

  • 3.设置一个类的静态字段(被final修饰、已在编译期把结果放在常量池的静态字段除外)==> 对应 putStatic 指令;

  • 4.调用一个类的静态方法 ==> 对应 invokeStatic 指令;

注意2:面试官可能还会问到你 JVM 类的加载机制?

这个时候你可以聊聊 classloader 双亲委派模型,这里不多赘述。

第四种: 饿汉,变种

public class Singleton {  
    private Singleton instance = null;  

    static {  
      instance = new Singleton();
    }  

    private Singleton (){}

    public static Singleton getInstance() {  
    return this.instance;  
    }  
} 

这里利用了 static 块来实例化对象,实际上和第三种差不多。

第五种: 静态内部类

public class Singleton {  

    private static class SingletonHolder { 
      private static final Singleton INSTANCE = new Singleton();
    }  

    private Singleton (){}

    public static final Singleton getInstance() {  
      return SingletonHolder.INSTANCE;  
    }  
} 

这种方式同样利用了 classloder 的机制来保证初始化 instance 时只有一个线程,它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要 Singleton 类被装载了,那么 instance 就会被实例化(没有达到 lazy loading 效果),而这种方式是 Singleton 类被装载了,instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,只有显示通过调用 getInstance 方法时,才会显示装载 SingletonHolder 类,从而实例化 instance。想象一下,如果实例化 instance 很消耗资源,我想让他延迟加载,另外一方面,我不希望在 Singleton 类加载时就实例化,因为我不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化 instance 显然是不合适的。这个时候,这种方式相比第三和第四种方式就显得很合理。

第六种:枚举

 public enum Singleton {  
   INSTANCE;  
   public void whateverMethod(){}  
 } 

这种方式是 《Effective Java》 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能自动避免序列化 / 反序列化攻击,以及反射攻击 (枚举类不能通过反射生成)。

第七种: 双重校验锁(DCL)

public class Singleton {  

    private volatile static Singleton singleton;  

    private Singleton (){}   

    public static Singleton getSingleton() {  
    if (singleton == null) {  
      synchronized (Singleton.class) {  
      if (singleton == null) {  
        singleton = new Singleton();}  
     }  
   }  
   return singleton;  
   }  
 } 

这个是第二种方式的升级版,俗称双重检查锁定。通过在 synchronized 的外面增加一层判断,就可以在对象一经创建以后,不再进入 synchronized 同步块。这种方案不仅减小了锁的粒度,保证了线程安全,性能方面也得到了大幅提升。

同时你还需要说说 volidate 这个关键词的作用是为了防止 JVM 指令重排,具体可以阅读我的另一篇文章 《你必须知道的 volatile 关键字》

总结

不过一般来说,第一种不算单例,第四种和第三种就是一种,如果算的话,第五种也可以分开写了。所以说,一般单例都是五种写法。

  • 1.懒汉

  • 2.饿汉

  • 3.双重校验锁(DCL)

  • 4.枚举

  • 5.静态内部类