首页 > 文章 > 前端

单例模式是什么？如何实现？

时间：2025-08-17 15:54:43 254浏览收藏

**单例模式是什么？如何实现单例？** 深入解析单例模式，这是一种确保类只有一个实例并提供全局访问点的设计模式。本文将详细介绍单例模式的概念及其在资源管理、配置管理等场景中的应用，并剖析五种常见的实现方式：饿汉式、懒汉式、双重检查锁、静态内部类和枚举。着重分析各种实现方式的优缺点，并结合实际场景，帮助开发者选择最合适的单例实现方案。同时，探讨单例模式潜在的问题，并提供替代方案，助力构建更健壮、可维护的应用系统。静态内部类和枚举因其线程安全和简洁性，在实际应用中更受青睐。

单例模式确保一个类只有一个实例并提供全局访问点，适用于资源管理、配置管理等场景，常见实现方式包括饿汉式、懒汉式、双重检查锁、静态内部类和枚举，其中静态内部类和枚举因线程安全且实现简洁更受推荐。

什么是单例模式？单例的实现方式

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在管理共享资源、配置对象等方面非常有用。

解决方案：

单例模式的核心在于控制实例的创建，并提供一个统一的访问接口。实现方式有很多，各有优缺点，下面列举几种常见的：

饿汉式（Eager Initialization）：

这是最简单的实现方式，在类加载时就完成了初始化，所以是线程安全的。

public class SingletonEager {
    private static final SingletonEager instance = new SingletonEager();

    private SingletonEager() {
        // 私有构造器，防止外部实例化
    }

    public static SingletonEager getInstance() {
        return instance;
    }
}

优点：简单，线程安全。

缺点：如果实例从始至终未使用，会造成资源浪费。

懒汉式（Lazy Initialization）：

只有在第一次调用 getInstance() 方法时才会创建实例。

public class SingletonLazy {
    private static SingletonLazy instance;

    private SingletonLazy() {
        // 私有构造器
    }

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

优点：延迟加载，节省资源。

缺点：线程不安全。上面的代码使用了 synchronized 关键字保证线程安全，但会降低性能。

双重检查锁（Double-Checked Locking）：

在懒汉式的基础上，通过双重检查锁提高性能。

public class SingletonDCL {
    private volatile static SingletonDCL instance;

    private SingletonDCL() {
        // 私有构造器
    }

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

volatile 关键字很重要，它可以防止指令重排序，确保多线程环境下单例的正确性。

优点：延迟加载，线程安全，性能相对较高。

缺点：实现较为复杂。

静态内部类（Static Inner Class）：
利用类加载机制保证线程安全。
```
public class SingletonStaticInner {
    private SingletonStaticInner() {
        // 私有构造器
    }

    private static class SingletonHolder {
        private static final SingletonStaticInner instance = new SingletonStaticInner();
    }

    public static SingletonStaticInner getInstance() {
        return SingletonHolder.instance;
    }
}
```
当外部类 SingletonStaticInner 被加载时，静态内部类 SingletonHolder 并不会被加载，只有当调用 getInstance() 方法时，才会加载 SingletonHolder 类，从而创建实例。
优点：延迟加载，线程安全，实现简单。
缺点：稍微有些难以理解。
枚举（Enum）：
这是最简洁的实现方式，也是《Effective Java》中推荐的方式。
```
public enum SingletonEnum {
    INSTANCE;

    public void doSomething() {
        // 执行一些操作
    }
}
```
优点：线程安全，防止反射攻击，防止反序列化重新创建对象，实现简单。
缺点：不能延迟加载，枚举类不能继承其他类。