Java设计模式-单例模式

1. 单例模式概述

单例模式是一种创建型设计模式，它保证一个类只能创建一个实例，并提供一个全局访问点来访问该实例。

2. 单例模式实现方式

针对常见的实现方式，分别介绍饿汉式、懒汉式、双重检查锁、静态内部类、枚举等单例模式的实现原理和代码示例。
常见的单例模式实现方式包括：

2.1. 饿汉式单例模式：

• 在类加载时就创建实例，并通过静态变量持有该实例。
• 优点：实现简单，线程安全。
• 缺点：在类加载时就创建实例，可能会导致资源浪费，尤其是在该实例的使用率较低的情况下。

/**
 * 饿汉式（静态常量）
 */
public class Singleton1 {
    // 构造器私有化，外部不能new(Singleton singleton = new Singleton();)
    private Singleton1() {

    }

    // 静态常量创建对象实例（本类内部创建对象实例）
    private final static Singleton1 instance = new Singleton1();

    // 提供一个公有的静态方法，返回实例对象
    public static Singleton1 getInstance() {
        return instance;
    }
}

/**
 * 饿汉式（静态代码块）
 */
class Singleton2 {
    // 构造器私有化，外部不能new(Singleton singleton = new Singleton();)
    private Singleton2() {

    }

    private static Singleton2 instance;
    //  静态代码块创建对象实例（本类内部创建对象实例）
    static {
        instance = new Singleton2();
    }

    // 提供一个公有的静态方法，返回实例对象
    public static Singleton2 getInstance() {
        return instance;
    }
}

2.2. 懒汉式单例模式：

• 延迟创建实例，只有在需要时才创建实例。
• 优点：延迟创建，节约资源。
• 缺点：多线程环境下需要考虑线程安全问题。

/**
 * 懒汉式-不安全（实例对象创建放在方法里创建实例）
 */
public class Singleton3 {
    // 构造器私有化，外部不能new(Singleton singleton = new Singleton();)
    private Singleton3() {

    }

    // 本类内部创建对象实例
    private static Singleton3 instance;

    // 提供一个公有的静态方法，当使用方法时，才创建并返回实例对象
    public static Singleton3 getInstance() {

        // ****** 注意：多线程下，判断语句可能会产生多个实例，建议不要使用

        if(instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

2.3. 静态内部类单例模式：

• 使用静态内部类来持有单例实例，实现延迟加载和线程安全。
• 优点：延迟创建，线程安全，性能较好。
• 缺点：无法防止通过反射创建多个实例。

/**
 * 静态内部类
 */
public class Singleton7 {
    // 构造器私有化，外部不能new(Singleton singleton = new Singleton();)
    private Singleton7() {

    }

    //  本类内部创建对象实例
    private static volatile Singleton7 instance;

    // 静态内部类，类中有一个静态属性Singleton7类的示例对象instance
    private static class SingletonInstance {
        private static final Singleton7 instance = new Singleton7();
    }

    // 提供一个公有的静态方法，返回实例对象
    public static synchronized Singleton7 getInstance() {
        return SingletonInstance.instance;
    }
}

2.4. 双重检查锁单例模式：

• 在懒汉式单例模式的基础上，使用双重检查锁机制来提高并发性能。
• 优点：延迟创建，线程安全，性能较好。
• 缺点：实现相对复杂。

/**
 * 双重检查
 */
public class Singleton6 {
    // 构造器私有化，外部不能new(Singleton singleton = new Singleton();)
    private Singleton6() {

    }

    //  本类内部创建对象实例
    private static volatile Singleton6 instance;

    // 提供一个公有的静态方法，返回实例对象
    // 解决线程安全问题，同时解决懒加载问题
    public static synchronized Singleton6 getInstance() {
        if(instance == null) {
            synchronized (Singleton6.class) {
                if(instance == null) {
                    instance = new Singleton6();
                }
            }
        }
        return instance;
    }
}

2.5. 枚举单例模式：

• 使用枚举来实现单例，枚举实例就是单例实例。
• 优点：简洁、线程安全、防止通过反射和序列化创建多个实例。
• 缺点：无法实现懒加载。

public enum EnumSingleton {
    INSTANCE;

    // 可以在枚举中添加其他成员变量和方法

    public void doSomething() {
        // 实现单例的逻辑
    }
}

3. 单例模式应用场景

单例模式在软件开发中有许多应用场景，下面列举几个常见的应用场景：

1. 配置管理器：单例模式可用于创建配置管理器，确保系统中只有一个配置管理器实例，提供全局的配置信息访问和管理。

2. 日志管理器：在一个应用程序中，通常只需要一个日志管理器来记录日志信息。使用单例模式可以确保只有一个日志管理器实例存在，避免多个日志实例的冗余和不一致。

3. 数据库连接池：在高并发的系统中，使用单例模式可以创建一个数据库连接池，确保数据库连接的有效复用和管理。

4. 线程池：在多线程编程中，单例模式可用于创建线程池实例，提供统一的线程管理和调度，避免创建多个线程池造成资源浪费。

5. 缓存管理器：在需要对数据进行缓存的场景中，单例模式可用于创建缓存管理器，确保只有一个缓存管理器实例，提供统一的数据缓存服务。

6. 全局计数器：在需要统计某个事件发生的次数或计数的场景中，可以使用单例模式创建一个全局计数器实例，确保计数的准确性和一致性。

需要注意的是，单例模式适用于需要全局唯一实例的场景，但过度使用单例模式可能导致代码的可测试性和可维护性下降。因此，在使用单例模式时应慎重考虑，并且在确保需要全局唯一实例的情况下才使用。

4. 单例模式的注意事项

在使用单例模式时，需要注意以下几个事项：

1. 线程安全性：在多线程环境下，确保单例对象的创建和访问是线程安全的。可以使用 synchronized 关键字或者使用双重检查锁方式来保证线程安全。

2. 延迟加载：单例模式通常使用延迟加载的方式，在需要时才创建单例对象。这可以减少系统启动时间和资源占用。但需要注意，如果在并发环境下多个线程同时访问单例对象，可能会导致创建多个实例的问题。

3. 序列化和反序列化：如果单例对象需要支持序列化和反序列化，需要实现 Serializable 接口，并提供 readResolve() 方法，确保反序列化时返回同一个实例。

4. 避免使用全局状态：单例模式本质上是一种全局访问的机制，因此需要谨慎使用。过度依赖单例模式可能导致代码的可测试性和可维护性下降，增加代码的耦合度。建议将单例对象的使用限制在合理的范围内，避免滥用。

5. 容器管理：在使用依赖注入（如 Spring 框架）进行对象管理时，容器本身已经提供了单例对象的管理机制，不需要手动实现单例模式。

6. 并发性能：在高并发场景下，单例模式可能成为瓶颈，因为所有线程都需要竞争同一个实例。可以考虑使用其他设计模式或者技术来替代单例模式，以提高并发性能。

综上所述，使用单例模式需要综合考虑线程安全性、延迟加载、序列化等方面的问题，并在合适的场景下使用，避免滥用。同时，需要根据具体需求选择适合的单例模式实现方式。

5. 单例模式的替代方案

除了单例模式，还有以下几种常见的替代方案：

1. 依赖注入（Dependency Injection）：通过依赖注入框架（如 Spring）管理对象的创建和生命周期，可以方便地实现对象的共享和管理。依赖注入可以避免单例模式的一些问题，如全局状态的过度依赖和耦合度高。

2. 工厂模式（Factory Pattern）：使用工厂模式来创建对象，工厂可以管理对象的生命周期并返回相应的实例。工厂模式可以灵活地控制对象的创建逻辑，并且可以方便地扩展和替换不同的实现。

3. 连接池（Connection Pool）：对于需要频繁创建和销毁的资源，如数据库连接、线程池等，使用连接池可以更好地管理和复用这些资源，避免频繁的创建和销毁操作。

4. 枚举（Enum）：在某些情况下，可以使用枚举来实现单例。枚举类型本身就是单例的，且在 Java 中保证线程安全和序列化安全。

5. 静态工具类（Static Utility Class）：对于一些无状态的工具类，可以使用静态方法和静态变量来实现共享和管理。静态工具类在使用时不需要创建实例，可以直接调用其中的方法。

需要根据具体的需求和场景选择适当的替代方案。单例模式适用于需要确保全局唯一实例的场景，但也可能带来一些问题，如全局状态的过度依赖和难以进行单元测试等。因此，在设计和实现时需要综合考虑各种因素。

6. 总结

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点。

要点总结：

• 单例模式只允许一个类有唯一的实例，通过控制对象的创建和访问方式来实现。
• 单例模式常用的实现方式有饿汉式、懒汉式、双重检查锁、静态内部类和枚举等。
• 单例模式的优点包括全局唯一性、节省资源、避免重复创建对象等。
• 单例模式的缺点包括可能导致全局状态的过度依赖、难以进行单元测试和并发性能问题等。
• 在使用单例模式时需要考虑线程安全性、延迟加载、序列化和反序列化、全局状态控制等问题。
• 单例模式适用于需要确保全局唯一实例的场景，但需要谨慎使用，避免滥用。

7. 参考

• 韩顺平-Java设计模式