创建型模式5.单例模式

创建型模式

1. 工厂方法模式（Factory Method Pattern）
2. 抽象工厂模式（Abstract Factory Pattern）
3. 建造者模式（Builder Pattern）
4. 原型模式（Prototype Pattern）
5. 单例模式（Singleton Pattern）

单例模式（Singleton Pattern） 是一种设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单例模式可以用于管理全局的资源，确保整个系统中只有一个对象来处理特定任务。

单例模式的关键特性：

1. 确保只有一个实例：单例模式确保在整个应用程序生命周期内，某个类只有一个实例。
2. 提供全局访问点：通过公共静态方法，可以访问该唯一的实例。
3. 延迟实例化：有时实例化时机会被延迟，只有在需要时才创建实例（懒汉式）。

1. 懒汉式（Lazy Initialization）

懒汉式单例模式在第一次使用时创建实例。它通常是线程不安全的，但可以通过同步来确保线程安全。

线程不安全的懒汉式：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // 延迟实例化
        }
        return instance;
    }
}

问题：

• 上述代码线程不安全。如果多个线程同时访问 getInstance() 方法，在没有同步的情况下，可能会创建多个实例。

线程安全的懒汉式：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // 延迟实例化
        }
        return instance;
    }
}

优点：

• 只有在需要实例时才创建（延迟加载）。

缺点：

• 使用 synchronized 来保证线程安全会影响性能，因为每次调用 getInstance() 都需要加锁。

2. 饿汉式（Eager Initialization）

饿汉式单例模式在类加载时立即创建实例。线程安全，且没有懒汉式的延迟加载问题，但不适用于需要在应用程序启动时创建对象的场景。

public class Singleton {
    // 静态实例在类加载时创建
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public static Singleton getInstance() {
        return instance;
    }
}

优点：

• 实例在类加载时创建，因此线程安全，不需要额外的同步操作。
• 不会有性能问题。

缺点：

• 如果类加载时没有使用单例对象，可能会浪费资源。

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

双重检查锁定是一种改进的懒汉式单例模式，使用 synchronized 来确保线程安全，但仅在实例为空时加锁，避免了每次调用 getInstance() 都加锁的性能损失。

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. 静态内部类方式（推荐）

静态内部类方式是实现单例模式的最佳方法之一。它利用了类的加载机制，保证了线程安全和延迟加载。

public class Singleton {
    // 静态内部类，只有在调用 getInstance 时才会加载
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
        // 私有构造函数，防止外部实例化
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：

• 线程安全，且实现简单。
• 延迟加载，只有在调用 getInstance() 时才实例化对象。
• 通过类的加载机制实现线程安全，不需要显式加锁。
• 具体的解析参考这个文章:静态内部类为什么在不需要加锁就是线程安全的单例模式-CSDN博客

总结：

1. 懒汉式（线程不安全）: 延迟实例化，适合需要延迟加载的场景，但需要处理线程安全问题。
2. 饿汉式（线程安全）: 类加载时实例化，线程安全，简单，但可能会造成资源浪费。
3. 双重检查锁定: 提供了懒加载和线程安全的优势，性能较高。
4. 静态内部类方式（推荐）: 最佳的单例实现方式，延迟加载，线程安全，且简单。

对于大多数情况，静态内部类方式是最推荐的实现方式，因为它利用了Java的类加载机制，在保证线程安全的同时也保持了延迟加载的优点。