EN

细说 Java 单例模式

字数统计: 2.4k阅读时长: 9 min
2015/05/06
loading

单例模式也叫单子模式,是一种常用的软件设计模式。本文按饿汉式、双重检查锁、静态内部类和枚举的顺序,介绍各自的初始化方式及边界。

技术复核(2026-10-13):这些实现思路仍然适用。下文以 Java 5+ 的内存模型和 Java SE 25 规范核查,修正“类加载即创建”“private 只在编译期生效”“枚举因抽象而不能反射”等说法。各个名为 Singleton 的代码块是替代方案,不应同时放进同一个源文件。

什么是单例模式

单例模式,也叫单子模式,是一种常用的软件设计模式。在应用这个模式时,单例对象的类必须保证只有一个实例存在。

这里的“只有一个”需要限定范围:同一个运行时类通过指定入口返回同一个实例。不同定义类加载器可以得到同名但不同的类,多个进程也不会共享一个静态实例。普通类还要单独考虑反射、反序列化等额外构造路径。JVMS 5.3:运行时类的身份

单例只解决实例的创建和访问,不自动让对象里的可变状态变得线程安全,也不替代资源的关闭或生命周期管理。

单例模式的构建

从初始化时机看,可以分为两类:

  1. 懒汉方式:延迟到第一次需要实例时创建。
  2. 饿汉方式:在持有静态字段的类初始化时创建。

类的加载、链接和初始化不是同一件事。下面的静态字段初始化通常由首次主动使用这个类触发,例如调用 getInstance();不能简单说成 JVM 一加载字节码就创建对象。JLS 12.4.1

1
2
3
4
5
6
7
8
9
10
public final class Singleton {
private static final Singleton INSTANCE = new Singleton();

private Singleton() {
}

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

这个写法利用类初始化的同步保证发布实例。如果初始化成本不高,也没有延迟创建的需求,它已经足够简单。

需要延迟创建时,可以使用双重检查锁(double-checked locking,DCL):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public final class Singleton {
private static volatile Singleton INSTANCE;

private Singleton() {
}

public static Singleton getInstance() {
if (INSTANCE == null) {
synchronized (Singleton.class) {
// 多个线程可能先后通过外层检查,获取锁后必须再次确认。
if (INSTANCE == null) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}

这里有两件事:锁内的第二次检查避免并发重复创建;volatile 保证构造过程中先前的写入能随引用一起安全发布。对同一个 volatile 字段的写 happens-before 后续读,不能只把它理解成“把某条指令固定在原位”。外层读不持锁,所以不能删掉 volatile。JLS 17.4.5

这个 DCL 写法要求 Java 5 / JDK 1.5 及以后 的内存模型;旧 JVM 即使用 volatile,也没有相同保证。JSR-133 作者 FAQ。示例还假定实例不被重置、构造期间不泄漏 this;实例后续字段的并发修改仍需自己的同步策略。

另一种单例模式

静态内部类持有方式(Initialization-on-demand holder idiom)通常比 DCL 更简洁:

1
2
3
4
5
6
7
8
9
10
11
12
public final class Singleton {
private Singleton() {
}

private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}

public static Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}

初始化外部 Singleton 类不会自动初始化 LazyHolder。首次读取 LazyHolder.INSTANCE 才触发持有类的初始化,由运行时协调其他线程等待初始化完成并保证可见性,无需再给字段加 volatile。这是类初始化语义的保证,不是某个编译器恰好做出的优化。JLS 12.4.2

INSTANCE 可以是 private:同一个顶层类内部允许访问嵌套类的私有成员,不要求它必须包级可见。JLS 6.6.1。原文链接的 Holder 写法讨论本次未能重新读取,保留作历史参考。

这种方式也有使用边界。若静态初始化失败,该类会进入错误状态,后续初始化尝试可能得到 NoClassDefFoundError;它不是自动重试机制。需要外部配置、显式重试或可替换生命周期的对象,不宜把这些要求塞进一个不可重置的 Holder。

使用枚举

如果对象适合固定为一个枚举常量,我推荐这个更简洁的写法,Java 5 起就可以用:

1
2
3
public enum Singleton {
INSTANCE;
}

使用时直接取 Singleton.INSTANCE。常量在枚举类初始化时创建;枚举不能再继承其他类,但可以实现接口。它仍不自动保证可变业务字段的线程安全。

普通单例类的序列化

单例再碰上序列化,事情就有点蛋疼了。前面的普通类没有实现 Serializable,因此不能直接用 Java 对象序列化保存。若确实需要可序列化的普通单例类,可以定义 readResolve(),让反序列化返回已有实例。下面是独立的完整示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.io.Serializable;

public final class SerializableSingleton implements Serializable {
private static final long serialVersionUID = 1L;
private static final SerializableSingleton INSTANCE =
new SerializableSingleton();

private SerializableSingleton() {
}

public static SerializableSingleton getInstance() {
return INSTANCE;
}

private Object readResolve() {
return INSTANCE;
}
}

readResolve() 是序列化机制识别的方法,不是重写 Object 的方法;这里不要加 @Override。它在对象读入后提供替代返回值,不表示过程里从未创建临时对象。带复杂引用图时还要考虑替换之前的引用,不能把它当所有情况下的绝对实例防护。序列化规范 3.7

transient 是否合适取决于字段是否应该进入序列化状态和对象图,不能为了“单例”把所有字段机械标成 transient。上面的无状态示例没有这类实例字段。

枚举为什么不能用 Constructor.newInstance 创建

这部分我当时没有深入了解。反射默认也做运行时访问检查,private 并非只在编译期生效。在权限允许时,setAccessible(true) 可以抑制部分检查;Java 9+ 的模块边界还可能阻止开启访问。AccessibleObject 合同

枚举有额外规则:JLS 8.9 禁止反射实例化枚举类,Constructor.newInstance 对枚举构造器抛出 IllegalArgumentException。这不是因为枚举一定为抽象类:上面只有 INSTANCE 的简单枚举隐式为 final,java.lang.Enum 基类的 abstract 不会自动传给子类。

枚举序列化保存的是什么

枚举可以序列化,并不是“禁止序列化”。ObjectOutputStream 对枚举采用特殊格式;流里有枚举类型描述和常量名,不会保存该常量的实例字段值。ObjectInputStream 按类型和名称解析已有常量,使用的是 Enum.valueOf(enumType, name),不是创建一个新的枚举对象。序列化规范 1.12

下面用前面的枚举版 Singleton 演示身份比较;辅助类使用 try-with-resources,要求 Java 7+。两个 public 类型分别放在 Singleton.java 和 SingletonSerializationDemo.java 中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public final class SingletonSerializationDemo {
public static void main(String[] args)
throws IOException, ClassNotFoundException {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
try (ObjectOutputStream out = new ObjectOutputStream(bytes)) {
out.writeObject(Singleton.INSTANCE);
}

Object restored;
try (ObjectInputStream in = new ObjectInputStream(
new ByteArrayInputStream(bytes.toByteArray()))) {
restored = in.readObject();
}
if (restored != Singleton.INSTANCE) {
throw new AssertionError("Enum identity was not preserved");
}
}
}

按上述合同,同一运行时枚举类型的比较应成立。这个示例读回的就是自己写入的内存数据,不是业务状态快照。枚举里自定义的 readObject、writeObject、readResolve 等钩子会被枚举序列化规则忽略。

友情提醒:已有数据需要兼容时,不要随意删除或重命名枚举常量。旧名称在接收端找不到时,Java 对象反序列化会失败;单独调用 Enum.valueOf() 查找不存在的名称则会抛 IllegalArgumentException。调整顺序并不改变按名称匹配的规则。

推荐阅读:

  1. 《Effective Java》第二版第 71 条“慎用延迟初始化”;第三版对应第 83 条,实例控制另见第 89 条。
  2. 《Core Java》第一卷的 volatile / 并发章节;原文“14.5.8”未注明版次,不能直接套到其他版本目录。
  3. JLS 17.4.5:happens-before 与 JLS 12.4:类初始化。
  4. JSR-133 作者 FAQ:理解 Java 5 前后 volatile 与 DCL 保证的变化。原 IBM developerWorks 中文文章地址现已重定向到 Java 栏目,旧文章入口已过期。
  5. 双重检查锁定与延迟初始化:历史译文,本次未能重新读取,技术依据以上述规范为准。

关于我 && 博客

下面是个人的介绍和相关的链接,期望与同行的各位多多交流,三人行,则必有我师!

  1. 博主个人介绍 :里面有个人的微信和微信群链接。
  2. 本博客内容导航 :个人博客内容的一个导航。
  3. 个人整理和搜集的优秀博客文章 - Android 性能优化必知必会 :欢迎大家自荐和推荐 (微信私聊即可)
  4. Android性能优化知识星球:付费社群已于 2026 年停止运营,不再招收新成员;此处保留历史介绍。

一个人可以走的更快 , 一群人可以走的更远

微信扫一扫

CATALOG
  1. 1. 什么是单例模式
  2. 2. 单例模式的构建
  3. 3. 另一种单例模式
  4. 4. 使用枚举
    1. 4.1. 普通单例类的序列化
    2. 4.2. 枚举为什么不能用 Constructor.newInstance 创建
    3. 4.3. 枚举序列化保存的是什么
  5. 5. 推荐阅读:
  • 关于我 && 博客