创建型模式-----单例模式

单例模式

2.1单例模式的定义

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

优点

• 内存中只有一个实例，减少内存开销，尤其是频繁创建和销毁实例时（如管理学院首页页面缓存）。
• 避免资源的多重占用（如写文件操作）。

缺点

• 没有接口，不能继承。
• 与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心实例化方式。

2.2单例模式有两种类型：

• 懒汉式：在真正需要使用对象时才去创建该单例类对象
• 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用

2.3代码实现

2.3.1、懒汉式，线程不安全

其流程图如下：

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

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

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

要想让线程变得安全，我们可以加上锁：

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 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;  
    }  
}

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
getInstance() 的性能对应用程序很关键。

这种方法叫：双检锁/双重校验锁（DCL，即 double-checked locking）

2.3.2、懒汉式，线程安全

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

关于类加载，涉及到JVM的内容，我们目前可以简单认为在程序启动时，这个单例对象就已经创建好了。

其流程图如下：

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

这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

2.3.3 破坏懒汉式单例与饿汉式单例

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

1：演示利用反射破坏单例模式

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
}

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

2：利用序列化与反序列化破坏单例模式

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() 方法读入对象时，它必定会返回一个新的对象实例，必然指向新的内存地址。

2.3.4 使用枚举

当然我们也可以使用枚举

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

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

防破坏的原理如下：

（1）防反射

枚举类默认继承了 Enum 类，在利用反射调用 newInstance() 时，会判断该类是否是一个枚举类，如果是，则抛出异常。

（2）防止反序列化创建多个枚举对象

在读入Singleton对象时，每个枚举类型和枚举名字都是唯一的，所以在序列化时，仅仅只是对枚举的类型和变量名输出到文件中，在读入文件反序列化成对象时，利用 Enum 类的 valueOf(String name) 方法根据变量的名字查找对应的枚举对象。

所以，在序列化和反序列化的过程中，只是写出和读入了枚举类型和名字，没有任何关于对象的操作。

小总结：

（1）Enum 类内部使用Enum 类型判定防止通过反射创建多个对象

（2）Enum 类通过写出（读入）对象类型和枚举名字将对象序列化（反序列化），通过 valueOf() 方法匹配枚举名找到内存中的唯一的对象实例，防止通过反序列化构造多个对象

（3）枚举类不需要关注线程安全、破坏单例和性能问题，因为其创建对象的时机与饿汉式单例有异曲同工之妙。

2.4 使用volatile防止指令重排

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

（1）为singleton分配内存空间

（2）初始化singleton对象

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

问题来了，什么是指令重排呢？

指令重排是指编译器或者处理器为了优化性能，在不改变程序单线程语义的情况下，对指令的实际执行顺序进行调整。它的目标是提高效率，例如通过减少 CPU 空闲时间、优化流水线执行等。

• 重排的原因：编译器或处理器进行指令重排的原因是为了优化程序的执行速度，并充分利用硬件资源。只要这种重排不影响单线程环境下的结果一致性，指令的顺序可以被打乱。
• 多线程问题：虽然指令重排在单线程中是无害的，但在多线程环境下，指令重排可能会引发线程间的可见性问题，导致共享数据不一致。例如，A 线程对变量的更新被 B 线程看到时，可能是指令重排后的结果，而不是程序设计的顺序。

假设有以下代码：

class Example {
    private int x = 0;
    private boolean flag = false;

    public void write() {
        x = 42;         // 1. 写入 x
        flag = true;    // 2. 写入 flag
    }

    public void read() {
        if (flag) {     // 3. 读取 flag
            System.out.println(x); // 4. 读取 x
        }
    }
}

在单线程环境中，write 方法总是先写入 x，然后写入 flag。而在多线程环境下，由于指令重排的原因，write 方法可能会被执行成：

flag = true;  // 先写入 flag
x = 42;       // 后写入 x

这可能导致另一个线程在 read 方法中看到 flag 为 true，但 x 的值还没有被正确写入，出现了错误的结果。

如何防止指令重排？

在 Java 中，volatile 关键字可以防止指令重排。它保证了两个方面：

1. 可见性：当一个线程修改了 volatile 变量的值，其他线程会立即看到这个修改。
2. 禁止指令重排：使用 volatile 修饰的变量会禁止编译器和处理器对其进行指令重排。

使用 volatile 防止指令重排

可以将 flag 变量声明为 volatile 来防止指令重排：

class Example {
    private int x = 0;
    private volatile boolean flag = false;

    public void write() {
        x = 42;         // 1. 写入 x
        flag = true;    // 2. 写入 flag
    }

    public void read() {
        if (flag) {     // 3. 读取 flag
            System.out.println(x); // 4. 读取 x
        }
    }
}

此时，volatile 保证了在 write 方法中，写入 x 一定发生在写入 flag 之前，且在 read 方法中，读取 flag 为 true 后，x 的值已经被正确写入。这种机制有效防止了指令重排带来的线程安全问题。

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

使用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;
    }
    
}

最后文章借鉴：参考文章