单例模式

说明

定义：保证一个类只有一个实例，并且提供一个全局访问点

场景：

• 重量级的对象，不需要多个实例，如线程池，数据库连接池等
• Java中的应用：Runtime

懒加载模式

懒加载模式：延迟加载，实例在需要时才实例化

// 单线程模式，非多线程安全
public class LazySingleton {
    private static LazySingleton instance;
    // 避免LazySingleton通过空构造实例化
    private LazySingleton() {
    }
    public static LazySingleton getInstance() {
        if (instance == null) {
            // 多线程测试，放大问题发生可能性！
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new LazySingleton();
        }
        return instance;
    }
}
// 测试
public class LazySingletonTest {
    public static void main(String[] args) {
        // 单线程测试
//        LazySingleton lazySingleton=LazySingleton.getInstance();
//        LazySingleton lazySingleton1=LazySingleton.getInstance();
//
//        System.out.println(lazySingleton == lazySingleton1);
        // 多线程环境
        new Thread(() -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
        new Thread(() -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
    }
}

避免多线程导致的问题：

方案一：使用 synchronized 对 getInstance() 方法加锁，优点是实现简单，能避免多线程导致的安全问题，缺点是每次访问都需要加锁，不管实例有没有被初始化，影响效率

public class LazySingletonMultiThread {
    // volatile修饰，防止指令重排序
    private volatile static LazySingletonMultiThread instance;
    // 避免LazySingleton通过空构造实例化
    private LazySingletonMultiThread() {
    }
    /**
     * 方案一：
     *   对getInstance加锁，就能够实现多线程环境下的单例模式
     *   缺点：每次访问都需要加锁，不管实例有没有被初始化，浪费资源和时间
     * @return
     */
    public static synchronized LazySingletonMultiThread getInstance(){
        if (instance == null){
            instance=new LazySingletonMultiThread();
        }
        return instance;
    }
}

方案二：仅对实例化步骤进行加锁，由于多个线程可能同时同步在实例化锁，因此在实例化前需要进行判断。

缺点：在字节码层面，即实例化阶段，由于可能发生的指令重排，赋值发生在初始化之前，导致下一个线程获取到空指针的现象。因此，需要volatile来修饰实例，避免指令重排。

public class LazySingletonMultiThread {
    // volatile修饰，防止指令重排序
    private volatile static LazySingletonMultiThread instance;
    // 避免LazySingleton通过空构造实例化
    private LazySingletonMultiThread() {
    }
    /**
     * 方案二：
     * 先判断instance是否为空，如果不为空，则不需要加锁，仅对实例化过程进行加锁；
     *
     * @return
     */
    public static LazySingletonMultiThread getInstance() {
        if (instance == null) {
            /**
             * 可能同时存在多个线程进入 synchronized 代码块，使得实例化多次，
             * 因此需要在synchronized内部对instance进行判断，避免多次实例化
             */ 
            synchronized (LazySingletonMultiThread.class) {
                if (instance == null) {
                    instance = new LazySingletonMultiThread();
                    /**
                     * 字节码层面：
                     * 可能发生指令重排：
                     *   JIT：Just In Time 即时编译
                     *   CPU
                     *  1. 分配空间
                     *  2. 初始化
                     *  3. 引用赋值
                     *
                     *  存在的问题：可能由于指令重排，导致引用赋值和初始化顺序颠倒，
                     *  而下一个过来的线程由于引用已经赋值，直接返回，存在获取到空指针的现象.
                     *
                     *  因此，需要volatile来修饰实例，避免指令重排。
                     */
                }
            }
        }
        return instance;
    }
}

饿汉模式

类加载在类的初始化阶段就已经完成了类的实例化，本质上就是借助于jvm的类加载机制，保证实例的唯一性。

类加载过程：

• 加载二进制数据到内存中，生成对应的Class数据结构；
  
• 连接：
  • 验证
    
  • 准备：给类的静态成员变量赋默认值
    
  • 解析
    
• 初始化：给类的静态变量赋初始值；
  

只有在真正使用对应的类时，才会触发初始化。如：当前类是启动类即main函数所在类，直接进行new操作，访问静态属性、访问静态方法，用反射访问类，初始化一个类的子类等。

public class HungrySingleton {
    // 在类加载最后一步初始化阶段被实例化
    private static HungrySingleton instance = new HungrySingleton();
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instance;
    }
    public static void main(String[] args) {
        HungrySingleton instance = HungrySingleton.getInstance();
        HungrySingleton instance2 = HungrySingleton.getInstance();
        System.out.println(instance == instance2);
    }
}

静态内部类

1. 本质上是利用类的加载机制来保证线程安全；
   

2. 只有在实际使用的时候，即调用getInstance()方法时才会触发类的初始化，属于懒加载的一种形式。
   

   public class InnerClassSingleton {
    private static class InnerClassHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton() {
    }
    /**
     * 实现了一个懒加载单例模式，该单例在调用getInstance()方法时被实例化，
     * 即在调用getInstance时，JVM会加载该内部类完成实例化，利用JVM的类加载机制实现线程安全
     *
     * @return 单例
     */
    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.instance;
    }
   }

反射攻击实例

public class Test {
    public static void main(String[] args) throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, InstantiationException {
        // 获取构造方法
        Constructor<InnerClassSingleton> constructor = InnerClassSingleton.class.getDeclaredConstructor();
        // 获取权限
        constructor.setAccessible(true);
        // 通过反射使用构造函数实例化
        InnerClassSingleton innerClassSingleton = constructor.newInstance();
        // 使用getInstance()方法实例化
        InnerClassSingleton innerClassSingleton1=InnerClassSingleton.getInstance();
        System.out.println(innerClassSingleton == innerClassSingleton1);  // false
    }
}

为了避免使用反射创建多实例，饿汉模式和内部类模式可以在构造函数中进行判断，抛出异常。

public class SingletonMode {
    private final static SingletonMode instance = new SingletonMode();
    private SingletonMode() {
            if (instance != null){
                throw new RuntimeException("单例模式不允许创建多个实例");
            }
    }
    public static SingletonMode getInstance(){
        return instance;
    }
}

枚举实现单例模式

通过JVM保证线程安全和反射安全；

public enum EnumSingleton {
    INSTANCE;
    public void print() {
        System.out.println("this.hashCode() = " + this.hashCode());
    }
}

序列化和反序列化

• 对不是枚举实现的单例模式单例的序列化和反序列化会破坏单例模式的实例唯一性，因此需要对单例进行处理：序列化和反序列化需要实现Serializable接口。
  

• 枚举类是天然的单例模式 ```java // 对内部类实现的单例模式进行改造 public class InnerClassSingletonSerializable implements Serializable { // 版本号 private static final long serialVersionUID = 42L;

  // 相当于方法签名 private Object readResolve() throws ObjectStreamException {

    return InnerClassSingletonSerializable.InnerClassHolder.instance;

  }

  private static class InnerClassHolder {

    private static InnerClassSingletonSerializable instance = new InnerClassSingletonSerializable();

  }

  private InnerClassSingletonSerializable() {

    /**
     * 防止通过反射创建实例！
     */
    if (InnerClassSingletonSerializable.InnerClassHolder.instance != null) {
        throw new RuntimeException("单例不允许多个实例！");
    }

  }

  /**

  • 实现了一个懒加载单例模式，该单例在调用getInstance()方法时被实例化，
  • 即在调用getInstance时，JVM会加载该内部类完成实例化，利用JVM的类加载机制实现线程安全 *
  • @return 单例 */ public static InnerClassSingletonSerializable getInstance() { return InnerClassSingletonSerializable.InnerClassHolder.instance; } }

//测试： public static void main(String[] args) throws IOException, ClassNotFoundException {

// 序列化会破坏单例模式
// 写入单例模式实例
InnerClassSingleton instance = InnerClassSingleton.getInstance();
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("test"));
oos.writeObject(instance);
oos.close();
// 读取单例实例
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("test"));
InnerClassSingleton singleton = (InnerClassSingleton) ois.readObject();
ois.close();
// 对比序列化前后是否为同一实例
System.out.println("(instance==singleton) = " + (instance == singleton));  // false：破坏了单例
// 写入单例模式实例,经过修改后的单例
InnerClassSingletonSerializable instanceSerializable = InnerClassSingletonSerializable.getInstance();
ObjectOutputStream oos1=new ObjectOutputStream(new FileOutputStream("testSerializable"));
oos1.writeObject(instanceSerializable);
oos1.close();
// 读取单例实例
ObjectInputStream ois1=new ObjectInputStream(new FileInputStream("testSerializable"));
InnerClassSingletonSerializable singletonSerializable = (InnerClassSingletonSerializable) ois1.readObject();
ois1.close();
// 对比序列化前后是否为同一实例
System.out.println("(instanceSerializable == singletonSerializable) = " + (instanceSerializable == singletonSerializable));

} // 输出： (instance==singleton) = false (instanceSerializable == singletonSerializable) = true ```