我向面试官讲解了单例模式，他对我竖起了大拇指，java高分面试指南

最新推荐文章于 2024-10-11 19:03:40 发布

m0_60666156

最新推荐文章于 2024-10-11 19:03:40 发布

阅读量131

点赞数

分类专栏：程序员文章标签：后端面试 java

本文链接：https://blog.csdn.net/m0_60666156/article/details/119587355

版权

程序员专栏收录该内容

16 篇文章 0 订阅

订阅专栏

    singleton = new Singleton();

}

return singleton;

}




这个方法其实是存在问题的，试想一下，如果两个线程同时判断 singleton 为空，那么它们都会去实例化一个Singleton 对象，这就变成多例了。所以，我们要解决的是线程安全问题。  

![在这里插入图片描述](https://img-blog.csdnimg.cn/20201026170813645.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTUyNzMzNA==,size_16,color_FFFFFF,t_70#pic_center)  

最容易想到的解决方法就是在方法上加锁，或者是对类对象加锁，程序就会变成下面这个样子

public static synchronized Singleton getInstance() {

if (singleton == null) {

    singleton = new Singleton();

}

return singleton;

}

// 或者

public static Singleton getInstance() {

synchronized(Singleton.class) {   

    if (singleton == null) {

        singleton = new Singleton();

    }

}

return singleton;

}




这样就规避了两个线程同时创建Singleton对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。



接下来要做的就是优化性能：目标是如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例



所以直接在方法上加锁的方式就被废掉了，因为这种方式无论如何都需要先获取锁

public static Singleton getInstance() {

if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton

    synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化

        if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支

            singleton = new Singleton();

        }

    }

}

return singleton;

}




上面的代码已经完美地解决了并发安全 + 性能低效问题：



*   第 2 行代码，如果 singleton 不为空，则直接返回对象，不需要获取锁；而如果多个线程发现 singleton 为空，则进入分支；

*   第 3 行代码，多个线程尝试争抢同一个锁，只有一个线程争抢成功，第一个获取到锁的线程会再次判断singleton 是否为空，因为 singleton 有可能已经被之前的线程实例化

*   其它之后获取到锁的线程在执行到第 4 行校验代码，发现 singleton 已经不为空了，则不会再 new 一个对象，直接返回对象即可

*   之后所有进入该方法的线程都不会去获取锁，在第一次判断 singleton 对象时已经不为空了



因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁）



完整的代码如下所示：

public class Singleton {

private static Singleton singleton;



private Singleton(){}



public static Singleton getInstance() {

    if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton

        synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化

            if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支

                singleton = new Singleton();

            }

        }

    }

    return singleton;

}

}




上面这段代码已经近似完美了，但是还存在最后一个问题：指令重排



[](https://gitee.com/vip204888/java-p7)使用 volatile 防止指令重排

-------------------------------------------------------------------------------------



创建一个对象，在 JVM 中会经过三步：  

（1）为 singleton 分配内存空间  

（2）初始化 singleton 对象  

（3）将 singleton 指向分配好的内存空间



指令重排序是指：JVM 在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能



在这三步中，第 2、3 步有可能会发生指令重排现象，创建对象的顺序变为 1-3-2，会导致多个线程获取对象时，有可能线程 A 创建对象的过程中，执行了 1、3 步骤，线程 B 判断 singleton 已经不为空，获取到未初始化的singleton 对象，就会报 NPE 异常。文字较为晦涩，可以看流程图：  

![在这里插入图片描述](https://img-blog.csdnimg.cn/20201026171057985.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTUyNzMzNA==,size_16,color_FFFFFF,t_70#pic_center)  

使用 volatile 关键字可以\*\*防止指令重排序，\*\*其原理较为复杂，这篇文章不打算展开，可以这样理解：使用 volatile 关键字修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换，这样在多线程环境下就不会发生 NPE 异常了。



> volatile 还有第二个作用：使用 volatile 关键字修饰的变量，可以保证其内存可见性，即每一时刻线程读取到该变量的值都是内存中最新的那个值，线程每次操作该变量都需要先读取该变量。



最终的代码如下所示：

public class Singleton {

private static volatile Singleton singleton;



private Singleton(){}



public static Singleton getInstance() {

    if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton

        synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化

            if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支

                singleton = new Singleton();

            }

        }

    }

    return singleton;

}

}




[](https://gitee.com/vip204888/java-p7)破坏懒汉式单例与饿汉式单例

--------------------------------------------------------------------------------



无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。



**利用反射破坏单例模式**



下面是一段使用反射破坏单例模式的例子

public static void main(String[] args) {

// 获取类的显式构造器

Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor();

// 可访问私有构造器

construct.setAccessible(true); 

// 利用反射构造新对象

Singleton obj1 = construct.newInstance(); 

// 通过正常方式获取单例对象

Singleton obj2 = Singleton.getInstance(); 

System.out.println(obj1 == obj2); // false

}




上述的代码一针见血了：利用反射，强制访问类的私有构造器，去创建另一个对象



[](https://gitee.com/vip204888/java-p7)利用序列化与反序列化破坏单例模式

-----------------------------------------------------------------------------------



下面是一种使用序列化和反序列化破坏单例模式的例子

public static void main(String[] args) {

// 创建输出流

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file"));

// 将单例对象写到文件中

oos.writeObject(Singleton.getInstance());

// 从文件中读取单例对象

File file = new File("Singleton.file");

ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));

Singleton newInstance = (Singleton) ois.readObject();

// 判断是否是同一个对象

System.out.println(newInstance == Singleton.getInstance()); // false

}




两个对象地址不相等的原因是：readObject() 方法读入对象时它必定会返回一个新的对象实例，必然指向新的内存地址。



[](https://gitee.com/vip204888/java-p7)让面试官鼓掌的枚举实现

------------------------------------------------------------------------------



我们已经掌握了懒汉式与饿汉式的常见写法了，通常情况下到这里已经足够了。但是，追求极致的我们，怎么能够止步于此，在《Effective Java》书中，给出了终极解决方法，话不多说，学完下面，真的不虚面试官考你了。



在 JDK 1.5 后，使用 Java 语言实现单例模式的方式又多了一种：枚举



枚举实现单例模式完整代码如下：

public enum Singleton {

INSTANCE;



public void doSomething() {

    System.out.println("这是枚举类型的单例模式！");

}

}




使用枚举实现单例模式较其它两种实现方式的优势有 3 点，让我们来细品。



**优势 1 ：一目了然的代码**



代码对比饿汉式与懒汉式来说，更加地简洁。最少只需要3行代码，就可以完成一个单例模式：

public enum Test {

INSTANCE;

}




我们从最直观的地方入手，第一眼看到这3行代码，就会感觉到少，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。



**优势 2：天然的线程安全与单一实例**



它不需要做任何额外的操作，就可以保证对象单一性与线程安全性。  

我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。


# **写在最后**

以上就是我的面试过程，为了这次面试，也收集了很多的面试题，反正我已经面过了，那就免费分享出来吧！

需要的朋友：**关注一下，然后[点击这里即可](https://gitee.com/vip204888/java-p7)免费领取**

以下是部分面试题截图

式：

public enum Test {

INSTANCE;

}




我们从最直观的地方入手，第一眼看到这3行代码，就会感觉到少，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。



**优势 2：天然的线程安全与单一实例**



它不需要做任何额外的操作，就可以保证对象单一性与线程安全性。  

我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。


# **写在最后**

以上就是我的面试过程，为了这次面试，也收集了很多的面试题，反正我已经面过了，那就免费分享出来吧！

需要的朋友：**关注一下，然后[点击这里即可](https://gitee.com/vip204888/java-p7)免费领取**

以下是部分面试题截图

![Java程序员秋招三面蚂蚁金服，我总结了所有面试题，也不过如此](https://img-blog.csdnimg.cn/img_convert/3f90ed90c526671889485f5c128cf89e.png)