单例模式深度剖析：各种实现方式的优缺点对比

张彦峰ZYF

已于 2025-04-20 18:10:45 修改

阅读量10w+

点赞数 402

CC 4.0 BY-SA版权

分类专栏：实用设计模式与进阶实操分析整合分享文章标签：单例模式后端 java

于 2020-04-21 11:15:59 首次发布

本文链接：https://blog.csdn.net/xiaofeng10330111/article/details/105652399

实用设计模式与进阶实操分析整合分享专栏收录该内容

10 篇文章

订阅专栏

（一）枚举式单例模式代码及分析：（Effective Java推荐单例模式）

（二）容器式单例模式代码及分析：（适用于实例非常多的情况，便于管理，但是是非线程安全的）

六、总结

参考书籍、文献和资料

干货分享，感谢您的阅读！

在软件设计中，单例模式是一种极为常见且重要的设计模式，它确保一个类只有一个实例，并提供全局访问点。这一特性使得单例模式在很多场景下都能有效地保证资源的统一管理和减少内存的浪费，尤其在诸如数据库连接池、线程池等资源管理的应用中，发挥着至关重要的作用。

然而，尽管单例模式非常实用，它的实现方式却并非一成不变。在不同的应用场景下，我们可能需要根据实际需求选择不同的单例实现策略——从简单的饿汉式单例，到需要懒加载的懒汉式，再到结合了性能优化的静态内部类实现，每种实现方式都有其优缺点，适用于不同的情况。

本篇文章将深入分析Java中的多种单例模式实现，帮助你了解它们的优缺点，并通过实际代码示例展示如何在实际项目中合理选择和应用这些模式。无论你是初学者，还是有一定经验的开发者，相信你都能从中找到提升代码设计质量和性能的宝贵经验。

一、单例模式的定义和应用场景

（一）定义及基本要点

单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。

该模式有三个基本要点：

一是这个类只能有一个实例；
二是它必须自行创建这个实例；
三是它必须自行向整个系统提供这个实例。

（二）应用场景

应用场景：J2EE中的ServlertContext、SerletContextConfig等、Spring框架应用中的ApplicationContext、数据库连接池等。

二、饿汉式单例模式

（一）基本代码展示分析

/**
 * 描述：饿汉式单例模式
 * 优点：没有任何锁，执行效率高，用户体验比懒汉式单例模式更好
 * 缺点：类加载的时候就初始化，不管用不用都占内存空间
 * 建议：适用于单例模式较少的场景
 *      如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
 *      如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。
 *
 * @author yanfengzhang
 * @date 2020-01-02 20:39
 */
public class HungrySingleton {
    private final static HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return HUNGRY_SINGLETON;
    }
}

（二）基本分析和建议

优点：没有任何锁，执行效率高，用户体验比懒汉式单例模式更好
缺点：类加载的时候就初始化，不管用不用都占内存空间
建议：

适用于单例模式较少的场景
如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。

三、懒汉式单例模式（双重检查锁）

（一）基本代码展示分析

/**
 * 描述：懒汉式单例模式---双重检查锁
 * 相比单锁而言，双重检查锁性能上虽然有提升，但是依旧用到了synchronized关键字总归要上锁，对程序性能还是存在一定的性能影响
 * 不算最优--存在优化空间
 *
 * 建议：如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
 *      如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。
 *
 * @author yanfengzhang
 * @date 2020-01-02 20:53
 */
public class LazyDoubleCheckSingleton {
    /**
     * volatile 关键字可以保证线程间变量的可见性，还有一个作用就是阻止局部重排序的发生
     */
    private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;

    private LazyDoubleCheckSingleton() {
    }

    public static LazyDoubleCheckSingleton getInstance() {
        if (null == lazyDoubleCheckSingleton) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (null == lazyDoubleCheckSingleton) {
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

（二）基本分析和建议

相比单锁而言，双重检查锁性能上虽然有提升，但是依旧用到了synchronized关键字总归要上锁，对程序性能还是存在一定的性能影响。注意里面volatile的使用！！！

建议：

如果我们在程序启动后，一定会加载到类，那么用饿汉模式实现的单例简单又实用；
如果我们是写一些工具类，则优先考虑使用懒汉模式，可以避免提前被加载到内存中，占用系统资源。

四、静态内部类实现单例模式

（一）基本代码展示分析

/**
 * 描述：屏蔽饿汉式单例模式的内存浪费问题和双重检查锁中synchronized的性能问题
 * 避免因为反射破坏单例
 *
 * @author yanfengzhang
 * @date 2020-01-02 21:08
 */
public class LazyInnerClassSingleton {
    /**
     * 使用LazyInnerClassSingleton的时候会先默认初始化换内部类
     * 如果没有使用，则内部类是不加载的
     */
    private LazyInnerClassSingleton() {
        /*为了避免反射破坏单例，需要在构造方法中增加限制，一旦出现多次重复创建，直接抛出异常*/
        if (null != Lazyholder.LAZY_INNER_CLASS_SINGLETON) {
            throw new RuntimeException("创建LazyInnerClassSingleton异常，不允许创建多个实例！");
        }
    }

    /**
     * 每一个关键字都不是多余的，static是为了使单例的空间共享，保证这个方法不会被重写、重载
     */
    public static final LazyInnerClassSingleton getInstance() {
        /*在返回结果前，一定会先加载内部类*/
        return Lazyholder.LAZY_INNER_CLASS_SINGLETON;
    }

    /**
     * 默认不加载
     */
    private static class Lazyholder {
        private static final LazyInnerClassSingleton LAZY_INNER_CLASS_SINGLETON = new LazyInnerClassSingleton();
    }
}

（二）基本分析和建议

屏蔽饿汉式单例模式的内存浪费问题和双重检查锁中synchronized的性能问题，同时考虑避免因为反射破坏单例问题。

相对而言性能最好！

五、注册式单例模式

注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。

注册单例模式有两种：枚举式单例模式+容器式单例模式

（一）枚举式单例模式代码及分析：（Effective Java推荐单例模式）

/**
 * 描述：注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。
 * 注册单例模式有两种：枚举式单例模式+容器式单例模式
 * 此为枚举式单例模式---Effective Java推荐单例模式
 *
 * @author yanfengzhang
 * @date 2020-01-03 09:59
 */
public enum EnumSingleton {
    /*枚举式单例模式*/
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

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

（二）容器式单例模式代码及分析：（适用于实例非常多的情况，便于管理，但是是非线程安全的）

/**
 * 描述：注册式单例模式/登记式单例模式，将每个实例都登记到一个地方，使用唯一的标识获取单例。
 * 注册单例模式有两种：枚举式单例模式+容器式单例模式
 * 建议：容器式单例模式适用于实例非常多的情况，便于管理，但是是非线程安全的。
 *
 * @author yanfengzhang
 * @date 2020-01-03 10:51
 */
public class ContainerSingleton {
    private ContainerSingleton() {
    }

    private static Map<String, Object> ioc = new ConcurrentHashMap<>();

    public static Object getBean(String className) {
        synchronized (ioc) {
            if (ioc.containsKey(className)) {
                return ioc.get(className);
            }
            Object obj = null;
            try {
                obj = Class.forName(className).newInstance();
                ioc.put(className, obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        }
    }
}

六、总结

单例模式作为一种经典的设计模式，在软件开发中扮演着重要的角色。它不仅能够保证系统中某一资源的唯一性，还能提供全局访问点，使得系统的资源管理更加高效和可靠。本文介绍了多种单例模式的实现方式，包括饿汉式单例、懒汉式单例（双重检查锁）、静态内部类实现单例以及注册式单例模式（枚举和容器式），并对每种方式的优缺点进行了详细分析。

在实际应用中，选择合适的单例实现方式至关重要。如果你的应用程序中单例类的初始化开销较小且始终需要加载，饿汉式单例可能是一个简单且高效的选择；而在需要延迟初始化的场景下，懒汉式单例或者静态内部类实现则能更好地节省资源。对于实例管理复杂的应用，注册式单例模式通过枚举和容器化的方式提供了灵活的解决方案。

尽管每种实现方式都有其优缺点，开发者应根据具体的需求、性能要求以及系统的复杂度来选择合适的模式。通过理解和掌握单例模式的实现，你不仅能提升程序的结构设计，还能在实际开发中避免常见的资源浪费和性能瓶颈。

希望本文的分析和代码示例能够帮助你更好地理解和应用单例模式，提升你的编程技能和系统设计能力。