单例模式详解

单例模式（Singleton Pattern）是一种常见的设计模式，属于创建型模式，它的主要目的是确保一个类只有一个实例，并提供全局访问点。单例模式通常用于管理共享资源，比如数据库连接池、线程池、配置文件读取器等。

单例模式的特点：

唯一性：单例类只有一个实例，避免了重复创建。
全局访问：该实例对外提供全局访问，其他类可以通过这个唯一的实例来访问资源。
懒加载：在需要时才创建实例，而不是在程序启动时就创建。

单例模式的实现方式

懒汉式（Lazy Initialization）：延迟实例化，只有在需要时才创建实例。
饿汉式（Eager Initialization）：在类加载时就创建实例，通常不考虑多线程的问题。
双重检查锁定（Double-Checked Locking）：结合懒汉式和饿汉式的优点，采用双重锁检查，确保在多线程环境下安全且高效地创建实例。
静态内部类（Bill Pugh Singleton Design）：通过静态内部类来实现单例，利用Java的类加载机制保证线程安全。

单例模式的优点：

节省内存：由于只有一个实例，所以能够节省内存空间。
全局访问：通过全局访问点，方便程序中其他类的调用。
避免资源浪费：避免了重复创建同一个实例，尤其是当实例创建较为复杂时，能够提升程序效率。

单例模式的缺点：

难以测试：由于单例类在全局范围内存在，可能会使得单元测试变得复杂。
扩展性差：如果需要扩展该类，可能会很难对单例类进行修改，破坏了开闭原则。

示例：单例模式的实现

1. 饿汉式

java

public class Singleton {
    // 类加载时立即实例化
    private static final Singleton instance = new Singleton();
    
    // 私有构造方法，防止外部实例化
    private Singleton() {}
    
    // 提供公共的静态方法来访问实例
    public static Singleton getInstance() {
        return instance;
    }
}

优点：线程安全，类加载时就创建实例，避免了多线程并发问题。

缺点：即使不使用单例，实例也会被创建，占用内存。

2. 懒汉式（线程不安全）

java

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

优点：在第一次调用 getInstance() 方法时创建实例，节省内存。

缺点：在多线程环境下可能会导致线程安全问题。

3. 双重检查锁定（Double-Checked Locking）

java

public class Singleton {
    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;
    }
}

优点：既能延迟实例化，又能保证线程安全。

缺点：稍微复杂，使用 volatile 关键字确保实例的正确性。

4. 静态内部类（推荐）

java

public class Singleton {
    // 静态内部类
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

优点：线程安全，延迟加载，并且利用JVM的类加载机制保证只会加载一次实例。

缺点：实现较为复杂，但更加优雅。

单例模式的应用场景：

配置管理：例如读取配置信息时，通常只需要一个全局实例来管理配置。
日志管理：日志对象通常在整个应用中是唯一的，避免了重复创建日志对象的浪费。
线程池管理：全局共享的线程池实例，避免了频繁的线程池创建和销毁。
数据库连接池：通过单例模式管理数据库连接池，确保资源的有效利用。

双重检查锁定（Double-Checked Locking） 是一种优化的单例模式实现，目的是解决多线程环境下懒汉式单例模式的性能问题。它结合了懒汉式和饿汉式的优点，同时避免了同步操作的性能开销。

背景

在懒汉式的实现中，getInstance() 方法是被同步的，这样可以保证线程安全，但每次调用 getInstance() 时都会进入同步代码块，这会产生性能开销。为了优化性能，可以采用双重检查锁定机制。

双重检查锁定的工作原理

双重检查锁定的核心思想是：

第一次检查：如果实例已经创建，就直接返回，不需要进入同步代码块，这样避免了同步带来的性能损耗。
加锁：如果实例为空，就进入同步代码块，这样确保只有一个线程能够创建实例。
第二次检查：在进入同步代码块后，重新检查实例是否为空，因为在进入同步块之前，可能已经有其他线程创建了实例。

双重检查锁定的代码实现

java

public class Singleton {
    // 使用 volatile 关键字来确保线程安全和防止指令重排序
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        // 第一次检查：如果实例已经创建，直接返回
        if (instance == null) {
            // 加锁，确保只有一个线程进入同步代码块
            synchronized (Singleton.class) {
                // 第二次检查：如果实例仍然为 null，才创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

解释

volatile 关键字：使用 volatile 确保在多线程环境下，instance 变量的更新是可见的，避免指令重排序。volatile 关键字保证了当一个线程修改 instance 时，其他线程可以立即看到修改后的值。
第一次检查：在方法的最外层先进行一次检查，如果 instance 已经被创建，就不需要进入同步代码块，从而避免同步带来的性能损耗。
加锁：当实例为空时，进入同步代码块。此时只会有一个线程能够进入同步块，确保实例的创建过程是线程安全的。
第二次检查：在同步代码块中，再次检查 instance 是否为空。因为在同步块外部，可能有其他线程已经创建了实例，所以需要第二次检查来防止重复创建。

为什么需要双重检查锁定？

避免性能损耗：如果没有第一次检查，每次调用 getInstance() 都需要进入同步代码块，这会带来不必要的性能损失。通过第一次检查，可以跳过已经创建实例的情况，从而提高效率。
保证线程安全：在多线程环境下，确保只有一个线程能够创建实例，不会出现多个实例的问题。
指令重排序问题：在 instance 的初始化过程中，可能会发生指令重排序，导致其他线程看到一个不完全初始化的对象。通过 volatile 关键字，可以避免这种问题。