[Java、Android面试]_19_单例模式（高频问题）

本人今年参加了很多面试，也有幸拿到了一些大厂的offer，整理了众多面试资料，后续还会分享众多面试资料。
整理成了面试系列，由于时间有限，每天整理一点，后续会陆续分享出来，感兴趣的朋友可关注+收藏

欢迎查看合集：
Java、Android面试高频系列文章合集

常见问题：

写一个单例模式

1.public class SingleInstance{
2.         public static instance = null;
3.         private SingleInstance(){};
4.         // 添加sychronized来进行线程安全
5.         public sychronized static SingleInstance getInstance(){
6.                    if(null == instance){
7.                             return new SingleIntance();
8.                    }
9.                    return instance;
10.         }
11.} 
1
2
3
4
5
6
7
8
9
10
11

此时的效率比较低，因为sychronized可能会使线程阻塞，那么可以利用静态内部类来实现：

1.public class Singleton {  
2.    private Singleton() {}    // 私有构造方法  
3.    // 静态内部类，用于延迟加载和创建单例实例  
4.    private static class SingletonHolder {  
5.        private static final Singleton INSTANCE = new Singleton();  
6.    }  
7.    // 公共静态方法，获取唯一实例  
8.    public static Singleton getInstance() {  
9.        return SingletonHolder.INSTANCE;  
10.    }  
11.}
1
2
3
4
5
6
7
8
9
10
11

为什么静态内部类可以实现线程安全且保证单例呢？

（1）延迟加载： 静态内部类不会在外部类加载时立即初始化，而是在首次访问内部类的静态成员（即 INSTANCE）时才会进行初始化。这就实现了懒加载，即只有在需要时才会创建单例实例。

（2）类加载机制： Java 类加载采用了类加载器加载类的方式，保证了类在首次访问时才会被加载。因此，静态内部类在外部类加载时并不会立即加载，只有在首次访问内部类的静态成员时才会触发类的加载和初始化。

（3）线程安全： 由于类加载和初始化在 JVM 中是线程安全的操作，所以静态内部类的初始化过程也是线程安全的。即使在多线程环境下，也可以保证只有一个线程会创建单例实例。

通过利用这些特性，静态内部类能够在需要时创建唯一的实例，同时保证了线程安全性，从而实现了单例模式。这种方式避免了加锁等复杂的同步机制，是一种非常高效且安全的实现方式。