Singleton模式即单例模式，是一种创建型设计模式，核心目标是保证一个类在整个程序运行期间只有一个实例，并且提供统一的全局访问入口。在单线程场景下，由于不存在多线程竞争的问题，单例模式的实现逻辑会更简单，但依然有不少开发者会因为对模式理解不到位写出不符合预期的代码。
单线程环境下Singleton模式的正确实现方式
1. 饿汉式实现
饿汉式是最简单的单例实现方式，它在类加载阶段就完成实例的初始化，天然保证了单例的唯一性。
public class HungrySingleton {
// 类加载时就初始化实例
private static final HungrySingleton INSTANCE = new HungrySingleton();
// 私有构造方法，防止外部通过new创建实例
private HungrySingleton() {}
// 全局访问点
public static HungrySingleton getInstance() {
return INSTANCE;
}
}
这种实现方式的优点是逻辑简单，没有线程安全问题，调用getInstance方法时直接返回已创建的实例，性能较好。缺点是如果实例的初始化过程比较耗时，或者实例在程序运行中根本不会被使用，会造成不必要的资源浪费。
2. 懒汉式实现（单线程适配版）
懒汉式的核心思想是延迟加载，只有在第一次调用getInstance方法时才创建实例，适合实例使用频率不高的场景。
public class LazySingleton {
// 初始时不创建实例
private static LazySingleton instance;
// 私有构造方法
private LazySingleton() {}
// 第一次调用时创建实例
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
在单线程环境下，这种方式可以正常工作，只有当getInstance第一次被调用时才会初始化实例，避免了饿汉式的资源浪费问题。不过这种实现方式在多线程环境下会出现线程安全问题，不能用于多线程场景。
3. 静态内部类实现
静态内部类实现结合了饿汉式和懒汉式的优点，既实现了延迟加载，又不需要额外的线程同步逻辑。
public class InnerClassSingleton {
// 私有构造方法
private InnerClassSingleton() {}
// 静态内部类，只有在被调用时才会加载
private static class SingletonHolder {
private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
// 全局访问点
public static InnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
这种方式的原理是，外部类加载时不会触发静态内部类的加载，只有当getInstance方法被调用时，才会加载SingletonHolder类并初始化INSTANCE实例，既保证了延迟加载，又利用类加载机制保证了单例的唯一性，是非常推荐的实现方式。
单线程环境下Singleton模式的常见误区
误区1：构造方法没有私有化
有些开发者在实现单例时忘记把构造方法设为私有，导致外部可以通过new关键字随意创建类的实例，完全违背了单例模式的初衷。
// 错误示例
public class WrongSingleton {
private static WrongSingleton instance;
// 构造方法没有私有化，外部可以直接new
public WrongSingleton() {}
public static WrongSingleton getInstance() {
if (instance == null) {
instance = new WrongSingleton();
}
return instance;
}
}
正确的做法是把构造方法的访问权限设为private，从根源上禁止外部通过new创建实例。
误区2：全局访问点方法不是静态的
单例模式需要提供全局访问点，这个方法必须是静态的，否则调用方法前需要先拿到类的实例，陷入先有鸡还是先有蛋的循环。
// 错误示例
public class WrongSingleton2 {
private static WrongSingleton2 instance;
private WrongSingleton2() {}
// 方法不是静态的，调用需要先有实例
public WrongSingleton2 getInstance() {
if (instance == null) {
instance = new WrongSingleton2();
}
return instance;
}
}
正确的getInstance方法需要加static修饰，让外部可以直接通过类名调用。
误区3：实例引用没有用static修饰
存储单例实例的变量必须是静态的，否则每次调用getInstance方法时，实例变量都是新的，无法保证全局唯一。
// 错误示例
public class WrongSingleton3 {
// 实例变量不是静态的，每次调用getInstance都是新的
private WrongSingleton3 instance;
private WrongSingleton3() {}
public static WrongSingleton3 getInstance() {
if (instance == null) {
instance = new WrongSingleton3();
}
return instance;
}
}
静态变量属于类，在类生命周期内只会存在一份，才能保证所有调用getInstance的地方拿到的是同一个实例。
误区4：使用同步锁实现单线程场景的单例
有些开发者不管场景是不是多线程，都给getInstance方法加synchronized锁，在单线程环境下会造成不必要的性能开销。
// 不必要的实现，单线程下加锁浪费性能
public class UnnecessarySyncSingleton {
private static UnnecessarySyncSingleton instance;
private UnnecessarySyncSingleton() {}
// 单线程场景不需要加锁
public static synchronized UnnecessarySyncSingleton getInstance() {
if (instance == null) {
instance = new UnnecessarySyncSingleton();
}
return instance;
}
}
如果明确是单线程环境，不需要加任何线程同步逻辑，避免额外的性能损耗。
不同实现方式的适用场景总结
为了更清晰地选择合适单例实现方式，以下是不同实现的特点对比：
| 实现方式 | 是否延迟加载 | 单线程安全性 | 适用场景 |
|---|---|---|---|
| 饿汉式 | 否 | 是 | 实例初始化简单、大概率会被使用的场景 |
| 懒汉式（单线程版） | 是 | 是 | 单线程环境、实例使用频率低的场景 |
| 静态内部类 | 是 | 是 | 单线程或需要兼容多线程、需要延迟加载的场景 |
在单线程环境下，开发者可以根据实际需求选择合适的实现方式，同时避开上述常见误区，就能写出正确的Singleton模式代码。
Singleton模式单例模式单线程懒加载饿汉式修改时间：2026-06-25 06:36:36