目录
单例模式的定义：
饿汉式--单例模式
定义：
案例：
优缺点：
懒汉式--单例模式：
定义：
1）懒汉式单例模式（非线程安全）
2）线程安全的懒汉式单例模式 （synchronized ）
3）双重检查锁定的懒汉式单例模式（线程安全）
单例模式的定义：
单例模式能保证某个类在程序中只存在唯⼀⼀份实例,⽽不会创建出多个实例.
要实现单例模式，通常需要做到以下几点：
- 私有化构造函数，防止外部通过new关键字创建实例。
- 提供一个静态的私有变量来保存类的唯一实例。
- 提供一个公共的静态方法来获取类的唯一实例，如果实例不存在则创建它。
单例模式具体的实现⽅式有很多.最常⻅的是"饿汉"和"懒汉"两种.
饿汉式--单例模式
定义：
- 在饿汉式单例模式中，“饿” 体现的是一种急切的状态。就好像一个很饿的人，在看到食物（这里类比于单例对象）的时候，会迫不及待地先把食物拿到手（创建单例对象）。在这个模式下，单例对象在类加载阶段就被创建出来，而不是等到真正需要使用这个对象的时候才去创建。这种方式比较急切，所以被称为 “饿汉模式”。
案例：
java">class Singleton {
// 私有静态成员变量，在类加载时就初始化实例
private static Singleton instance = new Singleton();
// 私有构造函数，防止外部通过new关键字创建实例
private Singleton() {}
// 公共静态方法，用于获取单例实例
public static Singleton getInstance() {
return instance;
}
}- ** 类加载过程中的创建**
- 在Java中，类加载是由类加载器（ClassLoader）完成的一个过程。当一个类被首次主动使用（例如创建这个类的实例、访问这个类的静态成员等情况）时，这个类就会被加载。对于上述的`Singleton`类，当`Singleton`类被加载时，`private static Singleton instance = new Singleton();`这行代码就会被执行。 因为类加载机制保证了一个类在一个Java程序中只会被加载一次（在正常情况下），所以`instance`对象也只会被创建一次。
- **访问控制保证单例性**
- 构造函数`private Singleton()`是私有的。这是非常关键的一点，它防止了外部类通过`new`关键字来创建`Singleton`类的新实例。外部类只能通过`public static Singleton getInstance()`方法来获取单例对象，而这个方法每次返回的都是在类加载阶段就已经创建好的`instance`对象，从而保证了整个系统中 只有一个`Singleton`类的实例存在。
优缺点：
**优点**
1 **线程安全**
- 由于单例对象是在类加载阶段就创建好的，而类加载过程在Java中是线程安全的（由Java虚拟机来保证）。所以在多线程环境下，这种方式可以保证多个线程访问`getInstance`方法时，获取到的都是同一个单例对象，不会出现多个线程创建多个实例的情况。
2- **实现简单**
- 从代码量和逻辑复杂度来看，饿汉式单例模式是比较简单的。只需要在类中定义一个私有静态变量并初始化，再提供一个公共静态方法来返回这个变量即可。这种简单的实现方式使得代码易于理解和维护。
**缺点**
- **可能会造成资源浪费**
- 如果单例对象的创建过程比较复杂，例如需要进行大量的初始化操作，如加载配置文件、建立网络连接等，并且这个单例对象在程序运行初期可能并不一定需要被使用。那么在类加载阶段就创建这个单例对象可能会导致资源的浪费。就好像提前准备了一顿丰盛的大餐（单例对象），但可能很长时间都没有人来吃（使用单例对象），而准备这顿大餐（创建单例对象）的过程又耗费了很多资源。
懒汉式--单例模式：
定义：
在懒汉模式下，实例在第一次使用时才进行创建，因此称为“懒汉”，在需要被用的时候被创建，突出一个字“懒”
1）懒汉式单例模式（非线程安全）
java">public class LazySingleton {
// 私有静态变量，用于存储单例对象
private static LazySingleton instance;
// 私有构造函数，防止外部通过new关键字创建新的实例
private LazySingleton() {}
// 公共的静态方法，用于获取单例对象
public static LazySingleton getInstance() {
if (instance == null) {
// 如果实例还未创建，则创建一个新的实例
instance = new LazySingleton();
}
return instance;
}
}
- 这种实现方式在单线程环境下是可以正常工作的。当第一次调用
getInstance方法时，会检查instance是否为null。如果是null，就会创建一个LazySingleton类的实例并赋值给instance，然后返回这个实例。之后再调用getInstance方法时，因为instance已经不是null了，所以会直接返回已创建的实例。
- 存在的问题：
- 在多线程环境下，这种实现方式是不安全的。假设两个线程同时调用
getInstance方法，并且此时instance为null。这两个线程都会执行instance = new LazySingleton();这一行代码，从而创建出两个不同的LazySingleton实例，这就违背了单例模式的初衷。
2）线程安全的懒汉式单例模式 （synchronized ）
java">public class ThreadSafeLazySingleton {
private static ThreadSafeLazySingleton instance;
private ThreadSafeLazySingleton() {}
// 使用synchronized关键字修饰方法，保证在多线程环境下的线程安全
public static synchronized ThreadSafeLazySingleton getInstance() {
if (instance == null) {
instance = new ThreadSafeLazySingleton();
}
return instance;
}
}
- 通过在
getInstance方法上添加synchronized关键字，保证了在多线程环境下，同一时刻只有一个线程能够进入这个方法。当一个线程进入getInstance方法并发现instance为null时，它会创建一个新的实例。其他线程如果在这个时候也尝试调用getInstance方法，就会被阻塞，直到第一个线程完成实例的创建并返回。
- 存在的问题：
- 这种方式虽然保证了线程安全，但是性能较差。因为每次调用
getInstance方法都需要获取锁，即使实例已经创建完成，这种不必要的同步操作会在高并发场景下成为性能瓶颈。
3）双重检查锁定的懒汉式单例模式（线程安全）
java">public class DoubleCheckedLockingSingleton {
// 使用volatile关键字保证变量的可见性和禁止指令重排序
private static volatile DoubleCheckedLockingSingleton instance;
private DoubleCheckedLockingSingleton() {}
public static DoubleCheckedLockingSingleton getInstance() {
if (instance == null) {
// 第一次检查，提高性能，避免不必要的同步操作
synchronized (DoubleCheckedLockingSingleton.class) {
if (instance == null) {
// 第二次检查，确保在同步块内也不会创建多个实例
instance = new DoubleCheckedLockingSingleton();
}
}
}
return instance;
}
}
- 首先，
if (instance == null)这一检查在同步块外进行，这是第一次检查。如果instance已经不是null，就可以直接返回实例，避免了进入同步块，从而提高了性能。- 当第一次检查
instance为null时，线程会进入同步块。在同步块内，又进行了一次if (instance == null)检查，这是第二次检查。这是为了防止在多个线程同时通过第一次检查后，只有一个线程能够进入同步块创建实例，其他线程在等待这个线程完成创建后，直接获取已创建的实例，而不会再次创建。- 使用
volatile关键字是非常关键的。在 Java 中，指令重排序可能会导致instance变量在没有完全初始化的情况下就被其他线程看到。volatile关键字可以保证变量的可见性，并且禁止指令重排序，确保了单例模式的正确性。
结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！
