1. 单例模式
单例模式（Singleton Pattern） 是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式，旨在确保一个类只有一个实例，并提供全局访问点来获取这个实例。单例模式在某些情况下非常有用，比如需要共享资源或管理全局状态的场景。
1.1 单例模式的要点
- 唯一实例：类只能有一个实例。
- 全局访问点：提供一个全局的访问点，用于获取该唯一实例。
- 防止外部创建实例：通过将构造方法设为私有，避免其他类直接创建对象。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1.2 单例模式的实现
单例设计模式分类两种：饿汉式、懒汉式。
饿汉式：类加载就会导致该单实例对象被创建。
饿汉式有三种实现方式：静态常量方式、静态代码块方式、枚举形式。
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建。
懒汉式有四种实现方式：线程不安全方式、线程安全方式、双重检查锁方式（线程安全方式优化）、静态内部类方式（线程安全方式优化）。
1.3 饿汉式单例模式
1.3.1 静态常量方式
静态初始化，类加载时创建实例
- 优点：这种写法比较简单，就是 在类加载的时候就完成实例化。避免了线程同步问题。
- 缺点：在类加载时就完成实例化，没有达到懒加载的效果。如果从未使用过这个实例，则会 造成内存的浪费。
类图：
public class Singleton {
// 静态初始化，类加载时创建实例
private static final Singleton instance = new Singleton();
// 私有化构造函数
private Singleton() {}
// 提供全局访问点
public static Singleton getInstance() {
return instance;
}
}
1.3.2 静态代码块方式
将类实例化的过程放在了静态代码块中，也是在类加载的时候，就执行静态代码块中的代码，初始化类的实例。
- 优缺点和上面的方式是一样的。
类图：
public class Singleton {
// 静态初始化，类加载时创建实例
private static final Singleton instance;
//在静态代码块中进行赋值
static {
instance = new Singleton();
}
// 私有化构造函数
private Singleton() {
}
// 提供全局访问点
public static Singleton getInstance() {
return instance;
}
}
1.3.3 枚举形式
通过枚举实现单例，是最推荐的实现方式，因为它简洁、线程安全，并且可以防止序列化和反射攻击。这种方式是Effective Java作者Josh Bloch 提倡的方式。
- 优点：线程安全，防止反序列化破坏单例，简洁优雅。
- 缺点：不适合需要延迟加载的情况。
类图：
public enum Singleton {
INSTANCE;
}
1.4 懒汉式单例模式
1.4.1 线程不安全方式
该方式起到了懒加载的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以 在多线程环境下不可使用这种方式。在实际开发中，不要使用这种方式.
- 优点：延迟加载实例，节省资源。
- 缺点：在多线程环境下可能会创建多个实例，线程不安全。
类图：
public class Singleton {
// 持有唯一实例，使用时再初始化
private static Singleton instance;
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 提供获取实例的方法
public static Singleton getInstance() {
if (instance == null) {
// 延迟创建实例
instance = new Singleton();
}
return instance;
}
}
1.4.2 线程安全方式
该方式也起到了懒加载效果，同时又解决了线程安全问题。但是在 getInstance() 方法上添加了 synchronized 关键字，导致该方法的执行效率特别低。从上面代码我们可以看出，其实就是在初始化 instance 的时候才会出现线程安全问题，一旦初始化完成就不存在了。
- 优点：延迟加载实例，节省资源。
- 缺点：执行效率特别低。
类图：
public class Singleton {
// 持有唯一实例，使用时再初始化
private static Singleton instance;
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 提供获取实例的方法，并且对该方法加锁
public synchronized static Singleton getInstance() {
if (instance == null) {
// 延迟创建实例
instance = new Singleton();
}
return instance;
}
}
1.4.3 双重检查锁方式（线程安全方式优化）
对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的。所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机，通过双重检查锁方式保证线程安全，同时确保懒加载。
优点：在保证线程安全的前提下，减少了锁的使用频率，提高了性能。
缺点：实现相对复杂，并且由于 Java 内存模型（JMM） 的原因，需要使用 volatile 关键字来确保正确的实例化。
类图：
public class Singleton {
// 持有唯一实例，使用时再初始化，volatile 保证可见性和有序性
private static volatile Singleton instance;
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 提供获取实例的方法
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
// 延迟创建实例
instance = new Singleton();
}
}
}
return instance;
}
}
1.4.4 静态内部类方式（线程安全方式优化）
静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。
- 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。
- 缺点：无明显缺点，被认为是单例模式的最佳实践之一。
类图：
public class Singleton {
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 静态内部类，持有单例实例
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
// 提供获取实例的方法
public static Singleton getInstance() {
// 只有在调用时才会加载 SingletonHolder 类
return SingletonHolder.INSTANCE;
}
}
1.5 单例模式破坏方式
尽管单例模式的目的是确保一个类只有一个实例，但在某些特殊情况下，可以通过一些方法破坏单例模式的约束。以下是几种常见的破坏单例模式的方式以及对应的解决方案（以静态内部类方式为例）。
1.5.1 反射机制
Java 的反射机制允许访问私有构造函数，即使构造函数是私有的，也可以通过反射调用，从而创建新的实例。
1.5.1.1 破坏方式
使用反射可以绕过单例类的私有构造方法，强行创建新的实例。
public class Client {
public static void main(String[] args) throws Exception {
// 创建 Singleton 类的对象
Singleton instance1 = Singleton.getInstance();
// 使用反射创建新实例
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
// 使用反射创建新实例
constructor.setAccessible(true);
Singleton instance2 = constructor.newInstance();
// 判断获取到的两个实例是否是同一个对象，输出：false，表示实例被破坏
System.out.println(instance1 == instance2);
}
}
1.5.1.2 解决方案
可以在构造函数中加上检查，防止通过反射创建多个实例。
public class Singleton {
// 私有化构造函数，防止外部创建实例
private Singleton() {
// 防止反射调用，防止反射攻击的额外防御
if (SingletonHolder.INSTANCE != null) {
throw new RuntimeException("Cannot create instance, use getInstance()");
}
}
// 静态内部类，持有单例实例
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
// 提供获取实例的方法
public static Singleton getInstance() {
// 只有在调用时才会加载 SingletonHolder 类
return SingletonHolder.INSTANCE;
}
}
这种方式可以在实例化过程中，检测是否已有实例，如果存在，则抛出异常，防止反射破坏单例。
1.5.2 序列化
在使用 Serializable 接口的情况下，反序列化会创建新的对象，破坏单例模式。
1.5.2.1 破坏方式
即使通过 getInstance() 方法获得了唯一实例，但序列化再反序列化会导致产生一个新的实例。
public class Client {
public static void main(String[] args) throws Exception {
// 创建 Singleton 类的对象
Singleton instance1 = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
// 将对象写入文件
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("instance1.ser"));
out.writeObject(instance1);
out.close();
// 从文件中读取对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("instance1.ser"));
Singleton instance = (Singleton) in.readObject();
in.close();
// 判断获取到的两个实例是否是同一个对象，输出：false，表示实例被破坏
System.out.println(instance == instance2);
}
}
1.5.2.2 解决方案
可以通过实现 readResolve() 方法，在反序列化时确保返回已有实例。
public class Singleton implements Serializable {
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 静态内部类，持有单例实例
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
// 提供获取实例的方法
public static Singleton getInstance() {
// 只有在调用时才会加载 SingletonHolder 类
return SingletonHolder.INSTANCE;
}
protected Object readResolve() {
// 返回唯一的实例
return SingletonHolder.INSTANCE;
}
}
readResolve() 方法在反序列化时会替换生成的实例，保证返回的是已有的单例对象。
1.5.3 克隆
如果类实现了 Cloneable 接口，并重写了 clone() 方法，克隆操作会生成一个新的实例，破坏单例模式。
1.5.3.1 破坏方式
通过克隆创建新实例。
public class Client {
public static void main(String[] args) throws Exception {
// 创建 Singleton 类的对象
Singleton instance1 = Singleton.getInstance();
Singleton instance2 = (Singleton) instance1.clone();
// 判断获取到的两个实例是否是同一个对象，输出：false，表示实例被破坏
System.out.println(instance1 == instance2);
}
}
1.5.3.2 解决方案
通过重写 clone() 方法，禁止克隆操作。
public class Singleton implements Cloneable {
// 私有化构造函数，防止外部创建实例
private Singleton() {
}
// 静态内部类，持有单例实例
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
// 提供获取实例的方法
public static Singleton getInstance() {
// 只有在调用时才会加载 SingletonHolder 类
return SingletonHolder.INSTANCE;
}
@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException("Singleton cannot be cloned");
}
}
这种方式阻止了单例对象被克隆，从而保证唯一性。
1.6 JDK源码解析-Runtime类
从下面源代码中可以看出 Runtime 类使用的是懒汉式单例模式（静态常量方式）来实现单例模式的。
public class Runtime {
private static final Runtime currentRuntime = new Runtime();
/**
* Returns the runtime object associated with the current Java application.
* Most of the methods of class {@code Runtime} are instance
* methods and must be invoked with respect to the current runtime object.
*
* @return the {@code Runtime} object associated with the current
* Java application.
*/
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don't let anyone else instantiate this class */
private Runtime() {}
}
