设计模式教程：单例模式（Singleton Pattern）

单例模式（Singleton Pattern） 是最简单的设计模式之一，属于 创建型模式，旨在确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。

单例模式的定义

单例模式的核心思想是确保某个类在整个应用程序中只能有一个实例，并提供一个全局的访问方法来获取该实例。

单例模式的目的

• 保证唯一性：确保一个类只有一个实例，这对于共享资源或状态非常重要。
• 节省资源：如果该类创建的对象很重，或初始化开销很大，单例模式避免了重复创建实例的开销。
• 全局访问：提供全局访问点，任何需要该类实例的地方都可以通过这个全局点来获取实例。

单例模式的结构

1. 私有构造函数：通过将构造函数设为私有的，防止外部直接创建对象。
2. 静态实例：在类内部声明一个静态的实例变量，用于保存唯一的实例。
3. 公共访问方法：提供一个公共的静态方法来访问这个唯一的实例。第一次调用时会创建实例，之后的调用直接返回这个实例。

单例模式的实现方式

1. 饿汉式单例（Eager Initialization）

饿汉式单例在类加载时就立即创建好唯一实例。它的缺点是即使没有用到单例对象，也会在程序启动时就创建实例，可能会导致资源浪费。

public class Singleton {
    // 创建静态实例，饿汉式
    private static final Singleton instance = new Singleton();
    
    // 私有构造函数，防止外部直接创建实例
    private Singleton() {}

    // 公共静态方法提供唯一实例
    public static Singleton getInstance() {
        return instance;
    }
}

优点：

• 代码简单，容易实现。
• 在类加载时实例就已经创建好，因此在多线程环境中天然线程安全。

缺点：

• 无论是否需要，类加载时都会创建实例，浪费资源。

2. 懒汉式单例（Lazy Initialization）

懒汉式单例在第一次需要时创建实例。它的缺点是在多线程环境下可能会出现线程安全问题，导致多个线程同时创建实例。

public class Singleton {
    // 声明实例，初始为null
    private static Singleton instance;
    
    // 私有构造函数，防止外部直接创建实例
    private Singleton() {}

    // 公共静态方法提供唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

• 只有在需要的时候才会创建实例，避免了不必要的资源浪费。

缺点：

• 在多线程环境下可能出现多个线程同时进入 if (instance == null) 判断，从而创建多个实例，导致线程安全问题。

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

为了解决懒汉式单例中的线程安全问题，双重检查锁定（DCL）通过在 getInstance() 方法中加入 synchronized 关键字进行控制，但只在实例为空时才加锁，提升性能。

public class Singleton {
    // 声明实例，初始为null
    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;
    }
}

优点：

• 解决了懒汉式的线程安全问题。
• 只有在实例为空时才会加锁，避免了每次调用时都加锁带来的性能问题。

缺点：

• 相比懒汉式，它实现稍微复杂，且在早期的 Java 版本中，双重检查锁定可能会存在一些内存可见性的问题。但在 Java 5 之后，volatile 关键字保证了内存的可见性，可以有效解决这个问题。

4. 静态内部类单例（Bill Pugh Singleton Design）

静态内部类单例是最推荐的实现方式。它结合了懒加载和线程安全，并且性能优于双重检查锁定。其原理是利用 静态内部类 在 Java 中的类加载机制，确保实例只有在第一次被访问时才创建。

public class Singleton {
    // 静态内部类实现单例
    private static class SingletonHelper {
        // 静态初始化器，JVM保证线程安全
        private static final Singleton INSTANCE = new Singleton();
    }

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

    // 公共静态方法提供唯一实例
    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

优点：

• 线程安全，延迟加载。
• 使用了静态内部类，JVM 会保证静态变量的初始化是线程安全的，且只有在第一次访问时才会初始化。
• 实现简单且性能较好。

缺点：

• 没有明显的缺点。

5. 枚举单例（Enum Singleton）

枚举单例是单例模式的最佳实现方式，它是由 Joshua Bloch（《Effective Java》作者）推荐的。使用枚举类来实现单例模式不仅简洁，而且它能够防止反射和序列化攻击。

public enum Singleton {
    INSTANCE;

    // 可以添加其他方法
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

优点：

• 由 JVM 本身提供保障，既能防止反射攻击，也能防止序列化创建新的实例。
• 实现简单，天然支持多线程环境。
• 提供了最安全和高效的单例模式实现。

缺点：

• 如果单例需要扩展其他接口或继承其他类，枚举类型无法满足这种需求（因为 Java 的枚举类型不能继承其他类）。

单例模式的优缺点总结

优点：

• 确保唯一性：单例模式能保证一个类只有一个实例，避免了实例的重复创建。
• 全局访问点：通过静态方法可以在程序中任何地方访问该实例。
• 延迟加载：在某些实现方式中（如懒汉式），实例可以延迟加载，节省资源。
• 避免资源浪费：对于资源密集型对象，单例模式避免了重复创建对象的开销。

缺点：

• 全局状态：单例模式会把状态和行为放在一个全局对象上，可能会导致过度依赖，降低系统的可测试性和可维护性。
• 难以扩展：单例模式会限制类的继承和扩展，因为它通过私有构造函数来控制对象的创建。
• 隐藏的依赖：如果单例对象被过度使用，可能会隐藏系统之间的依赖关系，增加系统的耦合度。

总结

单例模式在多线程编程中非常有用，可以保证只有一个实例，且通过全局访问点访问该实例。实现时需要特别注意线程安全性，在 Java 中，推荐使用 静态内部类单例 或 枚举单例 来实现单例模式，二者提供了线程安全且高效的解决方案。

版权声明

1. 本文内容属于原创，欢迎转载，但请务必注明出处和作者，尊重原创版权。
2. 转载时，请附带原文链接并注明“本文作者：扣丁梦想家
3. 禁止未经授权的商业转载。

如果您有任何问题或建议，欢迎留言讨论。