【Java多线程】单例模式（饿汉模式和懒汉模式）

单例模式的定义：

饿汉式--单例模式

定义：

案例：

优缺点：

懒汉式--单例模式：

定义：

1）懒汉式单例模式（非线程安全）

2）线程安全的懒汉式单例模式（synchronized ）

3）双重检查锁定的懒汉式单例模式（线程安全）

单例模式的定义：

单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。就好像在一个软件系统中，对于某些特定的资源或者对象，只需要一个就足够了，例如数据库连接池、配置文件管理器等。通过单例模式可以更好地控制这些对象的创建和访问，避免创建多个实例导致资源浪费或者数据不一致等问题。

单例模式能保证某个类在程序中只存在唯⼀⼀份实例,⽽不会创建出多个实例.

要实现单例模式，通常需要做到以下几点：

私有化构造函数，防止外部通过new关键字创建实例。
提供一个静态的私有变量来保存类的唯一实例。
提供一个公共的静态方法来获取类的唯一实例，如果实例不存在则创建它。

单例模式具体的实现⽅式有很多.最常⻅的是"饿汉"和"懒汉"两种.

饿汉式--单例模式

定义：

在饿汉式单例模式中，“饿” 体现的是一种急切的状态。就好像一个很饿的人，在看到食物（这里类比于单例对象）的时候，会迫不及待地先把食物拿到手（创建单例对象）。在这个模式下，单例对象在类加载阶段就被创建出来，而不是等到真正需要使用这个对象的时候才去创建。这种方式比较急切，所以被称为 “饿汉模式”。

案例：

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）懒汉式单例模式（非线程安全）

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 ）

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）双重检查锁定的懒汉式单例模式（线程安全）

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关键字可以保证变量的可见性，并且禁止指令重排序，确保了单例模式的正确性。