Java23种设计模式（一）：单例模式

Java 中的 23 种设计模式详解

设计模式是软件开发中的最佳实践，帮助开发者在面对复杂设计问题时提供有效的解决方案。GoF（Gang of Four）在其经典著作《设计模式：可复用面向对象软件的基础》中定义了 23 种设计模式。。本文将详细介绍23种经典设计模式，包括创建型模式、结构型模式和行为型模式，提供每种模式的定义、原理、优点、Java示例代码以及详细注释。

创建型模式（Creational Patterns）

创建型模式关注于对象的创建，提供了更灵活的对象创建方式。

创建型模式分为单例模式（Singleton Pattern）、原型模式（Prototype Pattern）、建造者模式（Builder Pattern）、工厂方法模式（Factory Method Pattern）、抽象工厂模式（Abstract Factory Pattern）

单例模式（Singleton Pattern）

问题：

在某些情况下，需要确保一个类只有一个实例，并且需要一个全局访问点来访问这个实例。例如，在一个应用程序中，一个配置管理器类需要保持一致的配置数据，以避免不同部分之间的配置冲突。

解决方案：

单例模式通过确保一个类只能创建一个实例，并提供一个静态方法或静态属性来访问这个实例。通常，单例类会将自己的构造函数声明为私有，以防止外部代码直接new创建实例。通过一个静态方法，单例类可以控制在运行时只能获得同一个实例。在需要协调访问共享资源（例如数据库连接）的场景中，单例能有效控制并发访问，防止产生冲突。

效果：

单例模式的应用可以确保在整个应用程序中只有一个实例存在，从而节省了资源和内存。它也可以提供一个全局的访问点，使得代码中的各个部分都可以方便地获取这个实例。然而，过度使用单例模式可能导致全局状态的难以控制，以及模块之间的紧耦合。在多线程环境下需要小心处理，以确保线程安全。

总之，单例模式是一种常用的设计模式，适用于需要全局唯一实例的场景。它的核心思想在于通过限制类的实例化来控制对象的数量，从而保证全局唯一性。

常见的单例模式实现方式有：饿汉式（静态常量）、饿汉式（静态代码块）、懒汉式（线程不安全）、懒汉式（线程安全——同步方法）、双重检查锁定（Double-Check Locking）、静态内部类、枚举实现等。

饿汉式（静态常量）

• 原理：在类加载时就创建好单例实例，这样保证了线程安全，因为 Java 类的加载是线程安全的。
• 优点：
  • ​​​​实现简单；
  • 线程安全，无需额外的同步控制。
• 缺点：
  • 没有延迟加载效果（即使应用中可能永远不会使用这个实例，也会在类加载时创建）。

Java示例

public class Singleton {
    // 类加载时创建实例，保证线程安全
    private static final Singleton INSTANCE = new Singleton();

    // 私有构造方法，防止外部实例化
    private Singleton() {
        // 防止通过反射调用私有构造方法创建多个实例
        if (INSTANCE != null) {
            throw new IllegalStateException("实例已经存在！");
        }
    }

    // 全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

饿汉式（静态代码块）

• 原理：利用静态代码块在类加载时创建实例，与静态常量方式类似。
• 优点：
  • ​​​​与静态常量方式相同，线程安全、实现简单。
• 缺点：
  • 同样没有实现延迟加载，类加载时就完成了实例化。

Java示例

public class Singleton {
    private static final Singleton INSTANCE;

    // 静态代码块，在类加载时执行
    static {
        INSTANCE = new Singleton();
    }

    private Singleton() {
        if (INSTANCE != null) {
            throw new IllegalStateException("实例已经存在！");
        }
    }

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

 懒汉式（线程不安全）

• 原理：在第一次调用 getInstance() 时创建实例，实现延迟加载。但在多线程环境下存在竞争条件，可能会创建多个实例。
• 优点：
  • 实现了延迟加载
• 缺点：
  • 在多线程场景下，两个线程可能同时判断 instance == null，从而各自创建一个实例，违背了单例原则。

Java示例

public class Singleton {
    // 延迟加载实例
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            // 多线程环境下可能出现问题
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式（线程安全——同步方法）【推荐使用】

• 原理：通过在 getInstance() 方法上加 synchronized 关键字，保证同一时刻只有一个线程进入该方法，从而确保只创建一个实例。
• 优点：
  • 实现简单，能够保证线程安全。
• 缺点：
  • 整个方法加锁，每次调用都需要同步，降低了性能（尽管实例只创建一次，但每次访问都涉及同步开销）。

Java示例

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    // 方法同步，保证线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查锁定（Double-Check Locking）【推荐使用】

• 原理：在进入同步块前先进行一次非同步检查，只有当实例为 null 时才进入同步块；在同步块内部再进行一次检查，确保只创建一次实例。
• 注意：必须将实例声明为 volatile，防止由于指令重排序造成线程安全问题。
• 优点：
  • 线程安全、实现延迟加载；
  • 同步代码块只在第一次初始化时执行，提高了效率。
• 缺点：
  • 实现相对复杂，需要正确使用 volatile 和双重检查机制。
• 深入分析：
  • 为什么需要双重检查？

        第一次检查是为了避免每次都进入同步块，提高效率；第二次检查是为了防止多个线程在同步块内同时创建实例。

• volatile 的作用

        在 Java 中，实例化对象（instance = new Singleton();）实际上可以分为以下几个步骤：
分配内存空间；

1. 初始化对象；
2. 将内存地址赋值给 instance 变量。
3. 由于指令重排序，步骤 2 和 3 可能会调换，如果没有 volatile 修饰，另一个线程可能会看到一个未完全初始化的对象。

Java示例

public class Singleton {
    // volatile 关键字确保多线程环境下变量的可见性和禁止指令重排序
    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;
    }
}

静态内部类【推荐使用】

• 原理：利用 JVM 类加载机制实现延迟加载和线程安全。静态内部类只有在外部类调用 getInstance() 时才会被加载，从而实现延迟加载效果，同时 JVM 保证类加载时的线程安全性。
• 优点：
  • 实现延迟加载；
  • JVM 在加载类时保证线程安全，无需显式同步；
  • 代码简洁易懂。
• 缺点：
  • 静态内部类的机制对初学者可能不够直观，需要理解类加载的原理。

Java示例

public class Singleton {
    private Singleton() {}

    // 静态内部类，负责持有 Singleton 实例
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 当调用 getInstance() 时，SingletonHolder 会被加载并初始化 INSTANCE
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

枚举实现【推荐使用】

• 原理：
  • 使用枚举类型实现单例，利用 Java 枚举的特性保证单例的唯一性和线程安全性。
  • 枚举实现不仅天然防止了反射攻击，还能防止反序列化重新创建实例，因为 Java 保证了每个枚举常量在 JVM 中都是唯一的。
• 优点：
  • 实现简单、代码精炼；
  • 天然线程安全；
  • 防止反射和反序列化破坏单例（反射很难创建枚举实例）。
• 缺点：
  • 如果需要继承其他类或实现某种接口，枚举的局限性可能会带来一些限制；
  • 在某些场景下，枚举的语法风格可能不符合团队的编码规范。
  • 不支持延迟加载，因为枚举常量在类加载时就已经被实例化了，需要延迟加载请使用双重检查锁定或静态内部类

Java示例

public enum Singleton {
    INSTANCE; // 枚举中的唯一实例

    // 可以添加其他方法
    public void someMethod() {
        // 实现具体逻辑
    }
}

public class TestSingleton {
    public static void main(String[] args) {
        // 获取枚举单例实例
        Singleton singleton = Singleton.INSTANCE;
        singleton.someMethod();
    }
}

单例模式实现方式对比

推荐使用场景

• 双重检查锁定：适用于需要延迟加载且对性能要求较高的多线程环境，但需要确保理解 volatile 的作用。
• 静态内部类：实现简洁、延迟加载且线程安全，适合大部分业务场景。
• 枚举实现：是实现单例的最简洁和安全的方式，推荐在 JDK1.5 及以上版本中使用，特别是在需要防止反射和反序列化攻击的场合