手写单例模式

原创已于 2025-03-02 21:25:12 修改 · 289 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#单例模式 #java #开发语言

于 2025-03-02 21:25:01 首次发布

设计模式专栏收录该内容

2 篇文章

订阅专栏

单例模式是一种常见的设计模式，确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。以下是几种常见的单例模式的实现方式：

饿汉式单例模式：在类加载时就创建单例实例，是线程安全的。

public class EagerSingleton {
    // 静态成员变量，在类加载时就初始化实例
    private static final EagerSingleton instance = new EagerSingleton();

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

    // 公共的静态方法，用于获取单例实例
    public static EagerSingleton getInstance() {
        return instance;
    }
}

懒汉式单例模式（线程不安全）：在第一次调用 getInstance 方法时才创建实例，但这种方式在多线程环境下是不安全的，可能会创建多个实例。

public class LazySingleton {
    // 静态成员变量，用于存储单例实例
    private static LazySingleton instance;

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

    // 公共的静态方法，用于获取单例实例
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

懒汉式单例模式（线程安全，使用 synchronized）：通过在 getInstance 方法上添加 synchronized 关键字来保证线程安全，但这种方式在每次调用 getInstance 方法时都会进行同步，性能较低。

public class SynchronizedLazySingleton {
    // 静态成员变量，用于存储单例实例
    private static SynchronizedLazySingleton instance;

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

    // 公共的静态方法，用于获取单例实例，添加synchronized保证线程安全
    public static synchronized SynchronizedLazySingleton getInstance() {
        if (instance == null) {
            instance = new SynchronizedLazySingleton();
        }
        return instance;
    }
}

懒汉式单例模式（线程安全，双重检查锁）：使用双重检查锁（DCL）来提高性能，只有在实例为 null 时才进行同步，减少了同步的开销。同时，使用 volatile 关键字来防止指令重排序，确保实例的正确初始化。

public class DoubleCheckLazySingleton {
    // 静态成员变量，使用volatile防止指令重排序
    private static volatile DoubleCheckLazySingleton instance;

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

    // 公共的静态方法，用于获取单例实例，双重检查锁保证线程安全和性能
    public static DoubleCheckLazySingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckLazySingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckLazySingleton();
                }
            }
        }
        return instance;
    }
}

静态内部类单例模式：利用静态内部类的特性，在外部类加载时，静态内部类不会被加载，只有在调用 getInstance 方法时，静态内部类才会被加载并初始化实例，保证了线程安全和懒加载。

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

    // 静态内部类，用于存储单例实例
    private static class SingletonHolder {
        private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }

    // 公共的静态方法，用于获取单例实例
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

枚举单例模式：使用枚举来实现单例模式，这是最简单且最安全的方式，因为枚举在 Java 中天然是线程安全的，并且只会被实例化一次。

public enum EnumSingleton {
    INSTANCE;


    public void doSomething() {
        System.out.println("执行单例实例的方法");
    }
}