在面向对象编程的世界里，设计模式是前辈们总结的“编码经验”，而单例模式无疑是其中最基础、最常用的一种。它的核心诉求简单而明确：保证某个类在整个程序运行生命周期中，永远只存在一个实例对象，不允许被外部多次实例化。这种模式的存在，是为了解决“全局唯一实例”的管理问题，也是后续学习复杂设计模式的基础。

一、单例模式的核心分类：懒汉式 vs 饿汉式

单例模式的实现方案有很多，但所有方案都可以归为两大核心类别：懒汉式单例和饿汉式单例。两者的根本区别只有一个——实例对象的创建时机，这也是后续所有实现方案的分歧根源，理解这一点，就能轻松理清各种实现的逻辑。

简单来说：

• 懒汉式：“不到万不得已不干活”，延迟创建实例；
• 饿汉式：“提前备好一切”，类加载时就创建实例。

二、懒汉式单例：延迟加载，按需创建

（一）懒汉式的核心特点

懒汉式，顾名思义就像一个“懒惰”的管理者，它不会在类被JVM加载时就创建实例，而是要等到第一次真正需要使用这个实例（即调用获取实例的方法）时，才会去完成对象的实例化操作。

它的核心特点可以总结为两点：

1. 延迟加载，节省内存：只有在实例被实际调用时才创建，若整个程序运行期间从未使用该实例，就不会占用任何内存资源，这是它的核心优势；
2. 天然存在线程安全隐患：在多线程环境下，多个线程可能同时触发“实例是否为空”的判断，进而同时执行实例化操作，最终创建出多个实例，违背单例模式“全局唯一”的核心要求，这是它的核心痛点，也是后续优化的重点。

（二）传统懒汉式：同步方法实现（简单但低效）

这是懒汉式最基础的实现方式，核心是通过synchronized关键字解决线程安全问题，代码实现简单，容易理解。

classSingleton{// 1. 私有构造方法：单例模式的基础前提privateSingleton(){}// 2. 声明静态成员变量，初始化为null，暂不创建实例privatestaticSingletonobj;// 3. 公共静态方法：获取实例，添加synchronized保证线程安全publicstaticsynchronizedSingletongetInstance(){// 判断实例是否为空，为空则创建if(obj==null){obj=newSingleton();}// 返回已创建的实例returnobj;}}

关键细节拆解

1. 私有构造方法的必要性：如果构造方法是公有的，外部代码就可以通过new关键字随意创建该类的实例，这就完全违背了单例模式“唯一实例”的要求。因此，所有单例模式的实现，都必须将构造方法私有化，禁止外部直接实例化。
2. 静态成员变量的意义：获取实例的方法是静态方法（static），而静态方法只能访问静态成员变量。同时，静态变量属于“类本身”，而非某个具体实例，全局唯一，这才能保证后续返回的实例是同一个对象。
3. synchronized关键字的作用：给getInstance()方法加上synchronized，相当于给这个方法加了一把“全局锁”。当一个线程正在执行这个方法时，其他线程必须排队等待，无法同时进入，这就避免了多个线程同时创建实例的问题，保证了线程安全。

这种实现的致命缺点：性能低下

虽然同步方法解决了线程安全问题，但它的性能开销极大。因为无论实例是否已经创建完成，每次调用getInstance()方法，都会触发加锁和释放锁的操作，而加锁操作本身是有系统开销的。如果这个方法被频繁调用，会显著降低程序的运行效率，这也是它仅作为“基础实现”，不推荐在实际开发中使用的原因。

（三）懒汉式优化：双检锁（Double-Checked Locking）实现（高效且安全）

针对传统懒汉式的性能问题，双检锁实现应运而生。它的核心优化思路是：只在实例未创建时进行加锁，实例创建完成后，后续调用直接返回实例，不再执行加锁逻辑，既保证了线程安全，又大幅提升了性能。

classSingleton{// 1. 私有构造方法privateSingleton(){}// 2. 静态成员变量，用volatile关键字修饰privatevolatilestaticSingletonobj;// 3. 公共静态方法：双检锁获取实例publicstaticSingletongetInstance(){// 第一次检查：实例已存在则直接返回，避免不必要的锁开销if(obj==null){// 加锁：类级别锁，仅允许一个线程进入临界区synchronized(Singleton.class){// 第二次检查：防止多个线程重复创建实例if(obj==null){obj=newSingleton();}}}returnobj;}}

关键细节拆解

双检锁的核心是“两次检查+一次加锁”，再配合volatile关键字，三者缺一不可，我们逐一来讲：

1. 第一次检查（外层if (obj == null)）：这是性能优化的关键。如果实例已经创建完成，直接返回实例，不需要进入后续的加锁逻辑，避免了传统实现中“每次调用都加锁”的性能开销，这也是双检锁和传统同步方法的核心区别。

2. 类级别锁（synchronized (Singleton.class)）：这里的锁不再是加在整个方法上，而是加在Singleton类的Class对象上，属于“类级别锁”。只有当实例未创建时，才会有线程进入这个同步代码块，且同一时间只有一个线程能进入，既保证了线程安全，又缩小了锁的作用范围，进一步提升性能。

3. 第二次检查（内层if (obj == null)）：这一步是必不可少的，也是很多人容易忽略的。原因是：多个线程可能同时通过第一次检查（此时实例还未创建），然后排队等待获取锁。当第一个线程获取锁、创建完实例并释放锁后，后续的线程获取到锁，如果没有第二次检查，就会误以为实例还未创建，进而再次执行实例化操作，最终创建出多个实例，违背单例模式的要求。因此，第二次检查是为了防止“排队线程”重复创建实例。

4. volatile关键字：解决指令重排序问题：这是双检锁实现中最核心、最容易被理解不透彻的点，我们分三步讲清楚它的作用：

   • 第一步：new操作不是“一步到位”的原子操作。很多人以为new Singleton()是一个单一操作，其实在JVM层面，它会被拆分成三个独立的步骤：
     ① 为实例对象分配一块内存空间；
     ② 在分配好的内存空间中初始化对象（执行构造方法中的所有逻辑）；
     ③ 将静态成员变量obj指向这块已经分配好的内存地址（此时obj就不再是null了）。
   • 第二步：JVM的“指令重排序”隐患。在没有约束的情况下，JVM为了提升执行效率，可能会对上述三个步骤进行“指令重排序”，将执行顺序调整为①→③→②。这种重排在单线程环境下没有任何问题，最终结果都是实例创建完成，但在多线程环境下会引发致命错误：当线程A执行完①和③（还未执行②，对象尚未完成初始化，是一个“半成品”），此时线程B调用getInstance()方法，外层第一次检查会发现obj不为null，于是直接返回这个“半成品”对象，后续线程B使用这个未完成初始化的对象时，会出现不可预期的运行时错误。
   • 第三步：volatile关键字的解决方案。volatile关键字在这里有两个核心作用（单例场景下重点是第二个）：
     一是保证变量可见性：线程对obj的修改（创建实例）会立即同步到主内存，其他线程读取obj时会直接从主内存获取，避免读取到“过期的null值”；
     二是禁止指令重排序：volatile通过插入“内存屏障”，强制JVM按照①→②→③的顺序执行new操作的三个步骤，从根源上避免了“半成品对象”的出现，保证了双检锁的线程安全。

这种实现方式完美解决了传统懒汉式的性能问题，同时保证了延迟加载和线程安全，是懒汉式单例中的“最优解”。但它的缺点是代码相对复杂，对volatile关键字的理解要求较高，新手容易出现遗漏或理解偏差。

三、饿汉式单例：立即加载，天然安全

（一）饿汉式的核心特点

饿汉式，和懒汉式相反，就像一个“饥饿的管理者”，它不会等待被调用，而是在类被JVM加载的那一刻，就完成实例对象的创建，后续调用获取实例方法时，直接返回提前创建好的实例即可。

它的核心特点可以总结为两点：

1. 天然线程安全，无需额外处理：JVM的类加载机制是线程安全的，类加载的“初始化阶段”（静态变量初始化）是单线程执行的，这个过程只会执行一次，因此静态实例变量的初始化天然保证了唯一性，不需要额外使用synchronized或volatile关键字。
2. 无延迟加载，可能浪费内存：类加载时就创建实例，无论后续是否会使用这个实例，都会提前占用内存资源。如果这个实例体积较大且全程未被使用，就会造成内存资源的浪费，这是它唯一的弊端。

（二）传统饿汉式：静态变量直接初始化（简单高效）

这是饿汉式最基础的实现方式，代码简洁到极致，没有任何复杂的逻辑，执行效率极高。

classSingleton{// 1. 私有构造方法privateSingleton(){}// 2. 类加载时直接创建实例，静态变量保证全局唯一privatestaticSingletonobj=newSingleton();// 3. 公共静态方法：直接返回已创建的实例publicstaticSingletongetInstance(){returnobj;}}

关键细节拆解

1. 实例创建时机：当这个Singleton类被JVM第一次加载时（比如第一次被引用时），静态成员变量obj会被立即初始化，执行new Singleton()创建实例，这个过程由JVM保证单线程执行，只会执行一次，因此无论后续多少个线程调用getInstance()方法，返回的都是同一个实例。
2. 方法的高效性：getInstance()方法中没有任何判断、没有任何锁操作，直接返回提前创建好的实例，执行效率达到最高，没有任何额外开销。
3. 内存浪费的隐患：如果这个Singleton类被加载了，但后续全程没有调用getInstance()方法，那么创建好的实例就会一直占用内存，直到程序结束，这是它无法避免的弊端。

（三）饿汉式优化：静态内部类实现（推荐首选，均衡所有优势）

针对传统饿汉式“无延迟加载”的弊端，静态内部类实现方案应运而生。它完美结合了饿汉式的天然线程安全和懒汉式的延迟加载两大优点，同时保持了代码的简洁性，是单例模式实现中的“最优推荐方案”。

classSingleton{// 1. 私有构造方法privateSingleton(){}// 2. 私有静态内部类：持有单例实例privatestaticclassSingletonHolder{// 内部类加载时创建实例，JVM保证线程安全privatestaticSingletoninstance=newSingleton();}// 3. 公共静态方法：获取实例publicstaticSingletongetInstance(){// 访问内部类的静态变量，触发内部类加载returnSingletonHolder.instance;}}

关键细节拆解（为什么它是首选？）

静态内部类的实现逻辑看似简单，实则蕴含了对JVM类加载机制的巧妙运用，我们逐点拆解它的优势：

1. 延迟加载的实现：这里有一个关键知识点——静态内部类不会随着外部类的加载而加载。当Singleton类被JVM加载时，静态内部类SingletonHolder不会被同时加载，只有当第一次调用getInstance()方法时，会触发对SingletonHolder.instance的访问，此时JVM才会加载SingletonHolder这个静态内部类，进而完成实例instance的创建。这就实现了“只有被调用时才创建实例”的延迟加载，解决了传统饿汉式内存浪费的问题。

2. 天然线程安全的保证：静态内部类SingletonHolder的加载，同样遵循JVM的类加载机制，其内部的静态变量instance的初始化，是在内部类加载的“初始化阶段”完成的，这个过程由JVM保证单线程执行，只会执行一次。因此，不需要任何显式的加锁操作，就可以保证实例的唯一性，线程安全级别极高。

3. 高性能的保持：getInstance()方法的实现和传统饿汉式一样，没有任何判断、没有任何锁操作，直接返回静态内部类中的实例，执行效率极高，没有任何额外开销。

4. 代码简洁易维护：相比于双检锁实现，静态内部类的代码更加简洁明了，没有复杂的volatile关键字和双重判断逻辑，后续开发和维护成本极低，即使是新手也能轻松理解和使用。

静态内部类实现的总结

这种实现方式几乎没有缺点，它兼顾了“延迟加载、线程安全、高性能、代码简洁”四大核心优势，是实际开发中最推荐、最常用的单例模式实现方式，没有之一。

四、单例模式核心细节深度剖析

（一）再谈volatile：不是万能的，只解决特定问题

在懒汉式双检锁实现中，volatile关键字是必不可少的，但我们需要明确它的适用场景和局限性，避免过度神化：

1. volatile只能修饰“成员变量”，不能修饰方法或代码块，它的作用对象是变量本身；
2. volatile无法保证“原子性”：如果一个操作是多步的，即使变量被volatile修饰，也无法保证这个多步操作的原子性（比如i++操作）。在双检锁实现中，原子性是由synchronized同步代码块保证的，volatile仅负责解决可见性和指令重排序问题；
3. volatile有一定的性能开销：虽然它的开销远小于synchronized，但相比于普通变量，volatile变量的读写操作仍然有轻微的性能损耗，因此不需要时不要随意使用。

（二）私有构造方法的“隐藏漏洞”

我们一直强调私有构造方法是单例模式的基础，但它并非“绝对安全”：在Java中，通过反射机制，可以突破私有构造方法的限制，强制调用私有构造方法，进而创建多个实例，违背单例模式的要求。

不过这种“反射攻击”在日常开发中场景极少，且静态内部类实现和后续的枚举单例，可以一定程度上规避这个问题（枚举单例可以完全避免），因此无需过度担忧，只需了解这个隐藏细节即可。

（三）懒汉式 vs 饿汉式：核心维度对比

为了让大家更清晰地分辨两者的差异，我们从核心维度做一个总结对比，方便快速选择：

五、补充：其他常见单例实现方式

除了上述核心实现，还有两种单例实现方式在实际开发中也较为常见，我们做一个补充说明：

（一）枚举单例：最安全的单例实现

在Java中，枚举类型是一种特殊的类，它的单例实现具有天然的优势，代码如下（极其简洁）：

enumSingleton{// 唯一枚举常量，即为单例实例INSTANCE;}

核心特点

1. 天然线程安全：枚举实例的创建是在枚举类加载时完成的，JVM保证单线程执行，天然避免多线程问题；
2. 完全避免反射攻击：Java反射机制明确规定，无法通过反射调用枚举类的构造方法，因此可以完全规避私有构造方法被反射突破的问题，安全性最高；
3. 无延迟加载：枚举类加载时就创建实例，可能造成内存浪费；
4. 灵活性不足：枚举类型一旦定义，就无法动态修改或扩展，不适用于需要动态配置的场景。

适用场景

对安全性要求极高、无需动态扩展、无需延迟加载的场景，是最安全的单例实现方式。

（二）Spring容器中的单例实现：注册表模式

我们在日常开发中使用Spring框架时，默认情况下Bean都是单例的，它的实现方式和我们前面讲的“纯粹单例模式”有所不同，采用的是注册表模式。

核心原理

1. Spring容器内部维护了一个“单例Bean注册表”（本质是一个键值对集合），用于缓存已创建的单例Bean；
2. 当容器需要创建Bean时，首先会查询注册表：如果注册表中已存在该Bean的实例，直接返回；如果不存在，就创建实例并将其存入注册表中；
3. Spring的单例是“容器级别的单例”，即同一个Spring容器中，同一个Bean的实例唯一，不同容器中可以存在多个相同Bean的实例。

核心特点

1. 灵活可控：支持懒加载（默认容器启动时创建，可配置为首次调用时创建），提供丰富的生命周期管理功能；
2. 适用于企业级开发：完美适配Spring框架的生态，是日常开发中接触最多的单例形式；
3. 并非“纯粹的单例”：和我们前面讲的“类级别的单例”不同，它是通过缓存实现的“容器级别的单例”。

（一）核心知识点回顾

1. 单例模式的核心诉求：保证一个类的实例全局唯一，禁止多次实例化；
2. 两大核心分类：懒汉式（延迟加载，需手动处理线程安全）、饿汉式（立即/按需加载，天然线程安全）；
3. 关键细节：双检锁中的volatile用于解决指令重排序，静态内部类巧妙运用JVM类加载机制，兼顾所有优势；
4. 核心矛盾：延迟加载与线程安全的平衡，性能与代码简洁性的平衡。

（二）最佳实践推荐（优先级从高到低）

1. 首选：静态内部类实现（饿汉式优化）：兼顾延迟加载、线程安全、高性能、代码简洁，满足99%的日常开发场景，是最均衡、最推荐的选择；
2. 次选：双检锁实现（懒汉式优化）：如果需要更灵活地控制实例创建过程，且能熟练掌握volatile关键字的使用，可以选择这种方式；
3. 特殊场景：枚举单例：对安全性要求极高、无需动态扩展的场景，是最安全的选择；
4. 企业级开发：Spring注册表单例：基于Spring框架开发时，直接使用容器的单例Bean管理，无需手动实现单例；
5. 避免使用：传统懒汉式（同步方法）、传统饿汉式（静态变量直接初始化）：前者性能低下，后者可能造成内存浪费，均有更优的替代方案。

单例模式是设计模式的入门基石，掌握它的原理和实现细节，不仅能帮助我们写出更高效、更安全的代码，也能为后续学习工厂模式、代理模式等复杂设计模式打下坚实的基础。