单例模式有哪些常见的实现方式？

八股文_设计模式面试题 0 7

参考回答

问题：单例模式有哪些常见的实现方式？

单例模式有多种实现方式，主要有以下几种常见的实现方式：

饿汉式（Eager Initialization）
懒汉式（Lazy Initialization）
双重检查锁定（Double-Check Locking）
静态内部类（Bill Pugh Singleton）
枚举单例（Enum Singleton）

每种方式在实现时的差异，通常与线程安全性、资源加载时机等因素相关。下面是对这些常见实现方式的详细介绍。

详细讲解与拓展

1. 饿汉式（Eager Initialization）

定义： 饿汉式单例模式在类加载时就立即创建实例，实例是类加载的一部分。

优点：
– 线程安全：由于类加载时就已经创建实例，不需要考虑并发问题。
– 实现简单：不需要处理线程同步等复杂问题。

缺点：
– 浪费资源：即使程序没有使用该实例，实例也会在应用启动时创建，可能浪费内存资源。

实现：

public class Singleton {
    // 静态实例，立即创建
    private static final Singleton INSTANCE = new Singleton();

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

    // 提供公共的静态方法来获取实例
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

2. 懒汉式（Lazy Initialization）

定义： 懒汉式单例模式实例是在第一次使用时才被创建。

优点：
– 节省资源：只有在需要时才会创建实例，避免了不必要的内存浪费。

缺点：
– 线程不安全：如果在多线程环境下，多个线程同时访问 getInstance() 方法，可能会创建多个实例。
– 需要同步：为了确保线程安全，通常需要加锁，但会影响性能。

实现（线程不安全）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

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

定义： 通过双重检查锁定来保证线程安全，同时减少不必要的同步开销。只有在实例为空时才会加锁，并且实例化后不再加锁。

优点：
– 性能较好：避免了每次调用 getInstance() 时都进行同步，提高了性能。
– 线程安全：通过双重检查来确保只有一个实例。

缺点：
– 复杂性：实现较为复杂，需要使用 volatile 关键字来确保实例的可见性。
– 可能会有轻微的性能损失：虽然双重检查减少了同步的次数，但仍然会有一些性能损失。

实现：

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;
    }
}

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

定义： 使用静态内部类来实现单例模式，利用类的加载机制保证线程安全，实例在 getInstance() 被调用时才创建。

优点：
– 线程安全：静态内部类的实例化是由JVM保证的，避免了同步带来的性能损失。
– 延迟加载：实例只有在第一次调用时才会被创建。

缺点：
– 没有显著的缺点，是一个高效且简单的实现。

实现：

public class Singleton {
    // 静态内部类
    private static class SingletonHelper {
        // 创建单例实例
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {}

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

5. 枚举单例（Enum Singleton）

定义： 使用枚举来实现单例模式，这是一种最简洁且线程安全的实现方式。枚举实例会在类加载时创建。

优点：
– 最简洁、线程安全：JVM保证了枚举的线程安全性以及单例的唯一性。
– 防止反序列化破坏单例：使用枚举可以自动防止反序列化时创建多个实例。

缺点：
– 枚举不支持延迟加载，实例会在类加载时就创建。

实现：

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        System.out.println("方法执行");
    }
}

总结

饿汉式：简单、线程安全，但会浪费资源，实例会在类加载时立即创建。
懒汉式：节省资源，延迟创建实例，但需要考虑线程安全性（不安全实现会导致问题）。
双重检查锁定：结合懒汉式的优点，减少了同步的开销，但实现复杂且略微影响性能。
静态内部类：高效且线程安全，是推荐的实现方式之一。
枚举单例：最简洁、安全，并且防止反序列化破坏单例，但不支持延迟加载。

根据具体的需求，可以选择合适的单例模式实现方式。对于线程安全且性能要求高的场景，静态内部类和双重检查锁定通常是不错的选择，而枚举单例则是在实现上最为简洁且安全的方案。

发表评论取消回复

后才能评论