🎍目录

⛳ 面试题-单例模式会存在线程安全问题吗？
- 🎨 一、单例模式-简介
- 🚜 二、饿汉式
- 🐾 三、懒汉式
- - 🎯 3.1、懒汉式：在调用 getInstance 的时候才创建对象。（线程不安全）
  - 🏓 3.2、改造1：对懒汉式进行加锁改造（线程安全）
  - 🔮 3.3、改造2：对懒汉式继续改造。（线程不安全）
  - 🏀 3.4、改造3（改造成功）：对懒汉式再次改造。（线程安全）
  - 3.5、总结
- 🏭 四、内部静态类
- - 🧰 4.1、反射攻击
  - 🧬 4.2、反序列化攻击
- ⭐ 五、枚举
- 📢 六、总结

⛳ 面试题-单例模式会存在线程安全问题吗？

答：会出现线程安全问题。

首先，在Java中创建单例实例的方式有：饿汉式、懒汉式、静态内部类、枚举等方式；

饿汉模式是天生线程安全的，饿汉模式在类创建的同时，就创建好了一个静态对象，又因为静态变量只会在类创建时执行一次，所以创建好的实例不会再改变，因此是线程安全的。

懒汉式不是线程安全的，当多并发情形下，可能会多个线程都创建实例，不能保证单例模式，可以改成双重校验锁，既保证了调用效率，又保证了线程安全。

静态内部类的方式相比于懒汉模式的优势是可以延迟加载，因为只有在静态内部类被调用时，JVM才会加载它，同时保证了线程安全和调用效率。

以上三种的创建方式都不能解决，反射、反序列化产生的线程安全问题；

使用枚举天然的防止反射和反序列化，既保证了线程安全，又保证了调用效率，但是不能延时加载；

🎨 一、单例模式-简介

单例模式是 Java 中常用的设计模式之一，属于设计模式三大类中的创建型模式。在运行期间，保证某个类仅有一个实例，并提供一个访问它的全局访问点。单例模式所属类的构造方法是私有的，所以单例类是不能被继承的。实现线程安全的单例模式有以下几种方式有：饿汉式、懒汉式、懒汉式改良版（双重同步锁），内部静态类、枚举；

🚜 二、饿汉式

天生是线程安全的！（但是无法应对反射、序列化的形式）

饿汉式在类创建的同时，就已经创建好了一个静态的对象供系统使用，以后不在改变；

public class Singleton {
 
    private static Singleton instance = new Singleton();
 
    private Singleton() {  // 私有的构造方法
    }
 
    public static Singleton getInstance() {
        return instance;
    }
 
}

这是实现一个安全的单例模式的最简单粗暴的写法，所以称之为饿汉式；

因为肚子饿了，想要马上吃到东西，不想等待生产时间。在类被加载的时候就把 Singleton 实例给创建出来，以后不在改变。

饿汉式的优点和缺点：

优点：实现简单、线程安全，调用效率高（无锁，且对象在类加载时就已创建，可直接使用）；
缺点：可能在还不需要此实例的时候就已经把实例创建出来了，不能延时加载（在需要的时候才创建对象）、使用反射，序列化创建对象依然可以不是单例的；

🐾 三、懒汉式

🎯 3.1、懒汉式：在调用 getInstance 的时候才创建对象。（线程不安全）

public class Singleton {  
      
        private static Singleton instance=null;  
          
        private Singleton() {};  
          
        public static Singleton getInstance(){  
              
            if(instance==null){
                //可能会有多个线程进入代码块，造成实例化多个对象
                instance=new Singleton();  
            }  
            return instance;  
        }  
    }

🏓 3.2、改造1：对懒汉式进行加锁改造（线程安全）

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

但是这种方式并不推荐，因为效率想对较低，每个线程在执行 getInstance 的时候都要进行同步。而如果 instance 已经实例化了可以直接返回，还需要进行改造；

🔮 3.3、改造2：对懒汉式继续改造。（线程不安全）

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

这种方式是线程不安全的，假如 A，B 两个线程同时进入到了 if(instance == null)的代码块， A 线程拿到了锁进入 synchronized代码块，对 instance 进行实例化，结束并释放锁，B 线程便拿到锁，依然会进入到 synchronized代码块对 instance 进行实例化。那么这就对 instance 进行了两次实例化。出现了线程安全的问题。

🏀 3.4、改造3（改造成功）：对懒汉式再次改造。（线程安全）

这种代码书写方式也称为双重同步锁

public class Singleton {  
  
    private static volatile Singleton instance=null;  
    
    private Singleton(){}
      
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) { 
                //在（3.3）的基础上多了一次判断，避免了线程安全问题
                if (instance == null) {  
                    instance = new Singleton();  
                }
            }  
        }  
        return instance;  
    }  
}

使用了double-check即check-加锁-check，减少了同步的开销；

在创建第一个对象时候，可能会有线程1，线程2两个线程进入getInstance()方法，这时对象还未被创建，所以都通过第一层check。接下来的synchronized锁只有一个线程可以进入，假设线程1进入，线程2等待。线程1进入后，由于对象还未被创建，所以通过第二层check并创建好对象，由于对象singleton是被volatile修饰的，所以在对singleton修改后会立即将singleton的值从其工作内存刷回到主内存以保证其它线程的可见性。线程1结束后线程2进入synchronized代码块，由于线程1已经创建好对象并将对象值刷回到主内存，所以这时线程2看到的singleton对象不再为空，因此通过第二层check，最后获取到对象。这里volatile的作用是保证可见性，同时也禁止指令重排序，因为上述代码中存在控制依赖，多线程中对控制依赖进行指令重排序会导致线程不安全。

优点：线程安全，可以延时加载，调用效率比锁加在方法上高。

另外，需要注意 instance采用 volatile 关键字修饰也是很有必要。

instance采用 volatile 关键字修饰也是很有必要的， instance = new Singleton();
这段代码其实是分为三步执行：
1. 为 instance 分配内存空间；
2. 初始化 instance ；
3. 将 instance 指向分配的内存地址；

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

3.5、总结

相比于饿汉式，懒汉式显得没那么 “饿”，在真正需要的时候在去创建实例。

懒汉式的优点和缺点：

优点：线程安全的，可以延时加载。
缺点：调用效率不高（有锁，且需要先创建对象）、使用反射，序列化创建对象依然可以不是单例的

🏭 四、内部静态类

public class Singleton {
    private Singleton() {
    }

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

    private static class SingletonFactory {
        private static Singleton instance = new Singleton();
    }
}

静态内部类只有被主动调用的时候，JVM才会去加载这个静态内部类。外部类初次加载，会初始化静态变量、静态代码块、静态方法，但不会加载内部类和静态内部类。

优点：线程安全，调用效率高，可以延时加载。

似乎静态内部类看起来已经是最完美的方法了，其实不是，可以还存在反射攻击和反序列化攻击。

🧰 4.1、反射攻击

public class Singleton {
    private Singleton() {
    }

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

    private static class SingletonFactory {
        private static Singleton instance = new Singleton();
    }
    
    public static void main(String[] args) throws Exception {
    Singleton singleton = Singleton.getInstance();
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton newSingleton = constructor.newInstance();
    System.out.println(singleton == newSingleton);
}
    
}

运行结果：false

通过结果看，这两个实例不是同一个，违背了单例模式的原则；

🧬 4.2、反序列化攻击

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.8.1</version>
</dependency>

这个依赖提供了序列化和反序列化工具类。

Singleton 类实现了 java.io.Serializable接口。

public class Singleton implements Serializable {
 
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
 
    private Singleton() {
 
    }
 
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
 
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        byte[] serialize = SerializationUtils.serialize(instance); // 序列化为一个数组
        Singleton newInstance = SerializationUtils.deserialize(serialize); // 通过刚才序列化的数组，进行反序列化
        System.out.println(instance == newInstance);
    }
 
}

输出结果：false，表示不是一个实例；

如果要解决 Singleton 类的实力在序列化和反序列化过程中仍然是唯一的，需要添加一个readResolve()方法到 Singleton 类中，以便在反序列化是返回相同的实例。如：

private Object readResolve() throws ObjectStreamException {
    return getInstance();
}

在 Java 中，readResolve() 方法是一个特殊的方法，用于在对象反序列化过程中控制返回的实例。它主要用于解决单例模式在反序列化时可能出现的问题。

⭐ 五、枚举

最佳的单例实现模式就是枚举模式。写法简单，线程安全，调用效率高，可以天然的防止反射和反序列化调用，不能延时加载。

public enum Singleton {
    
    INSTANCE;
    
    public void doSomething() {
        System.out.println("doSomething");
    }
}

调用方法：

public class Main {
 
    public static void main(String[] args) {
        Singleton.INSTANCE.doSomething();
    }
 
}

直接通过Singleton.INSTANCE.doSomething()的方式调用即可。

枚举如何实现线程安全？反编译后可以发现，会通过一个类去继承该枚举，然后通过静态代码块的方式在类加载时实例化对象，与饿汉类似。https://blog.csdn.net/wufaliang003/article/details/81395411

如何做到防止反序列化调用？每一个枚举类型及其定义的枚举变量在JVM中都是唯一的，Java做了特殊的规定，枚举类型序列化和反序列化出来的是同一个对象。

除此之外，枚举还可以防止反射调用。

📢 六、总结

综上，线程安全的几种单例模式比较来看：

枚举（无锁，调用效率高，可以防止反射和反序列化调用，不能延时加载）> 静态内部类（无锁，调用效率高，可以延时加载）> 双重同步锁（有锁，调用效率高于懒汉式，可以延时加载）> 懒汉式（有锁，调用效率不高，可以延时加载）~= 饿汉式（无锁，调用效率高，不能延时加载）

注：只有枚举类型能防止反射和反序列化；