01.3.2.1 单例模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 单例的问题定义、角色与生命周期边界
- Java 五种实现与线程安全、指令重排
- Go
sync.Once与包级初始化 - Python 模块级实例、
__new__、装饰器、元类 - PHP 静态属性与 FPM 进程模型
- C#
static readonly、Lazy<T>、依赖注入作用域 - TypeScript/JavaScript 模块缓存与打包多副本
- Rust
OnceLock与全局可变状态的约束 - Spring、ASP.NET Core、Laravel、Gin、Pinia 中的真实形态
- 单例被破坏的途径与分布式唯一性
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.1-001 | 单例模式解决什么问题?为什么面试几乎必考? | 基础 | 已完成 | 意图与边界 |
| 01.3.2.1-002 | Java 单例的五种实现怎么选? | 基础 | 已完成 | 饿汉/DCL/内部类/枚举 |
| 01.3.2.1-003 | 双重检查锁为什么必须加 volatile? | 进阶 | 已完成 | JMM 与指令重排 |
| 01.3.2.1-004 | Go 怎么实现单例?sync.Once 和包初始化有什么区别? | 进阶 | 已完成 | 并发原语 |
| 01.3.2.1-005 | Python 单例有哪些写法?GIL 能保证线程安全吗? | 进阶 | 已完成 | 动态语言陷阱 |
| 01.3.2.1-006 | PHP 单例在 FPM 下真的「唯一」吗? | 进阶 | 已完成 | 进程模型 |
| 01.3.2.1-007 | C# 单例为什么推荐 Lazy<T>? | 进阶 | 已完成 | 延迟与线程安全 |
| 01.3.2.1-008 | TypeScript/JavaScript 的单例为什么可能不止一个? | 进阶 | 已完成 | 模块系统 |
| 01.3.2.1-009 | Rust 为什么很难写出经典单例? | 高级 | 已完成 | 所有权与全局状态 |
| 01.3.2.1-010 | Spring、ASP.NET Core、Laravel 里的「单例」是什么? | 进阶 | 已完成 | 容器作用域 |
| 01.3.2.1-011 | 哪些方式会破坏单例?分布式场景还成立吗? | 进阶 | 已完成 | 反射/序列化/多进程 |
| 01.3.2.1-012 | 单例、静态工具类、依赖注入怎么取舍? | 进阶 | 已完成 | 可测试性 |
01.3.2.1-001 单例模式解决什么问题?为什么面试几乎必考?
一句话结论
单例保证一个类型在一个进程内只有一个实例,并提供一个受控的访问点;它解决的是「共享有状态资源被重复创建」的问题,不是「想全局访问」的问题。
概念解释
- 意图:控制实例化次数,把创建权从调用方收回到类型自身。
- 三个角色:私有构造器(禁止外部
new)、类型内部持有唯一实例、公开的获取入口。 - 典型对象:配置中心、连接池、注册表、日志器、缓存管理器、进程内 ID 生成器。
- 边界:单例的作用域是「进程 + 类加载器」级别,跨进程、跨 Pod、跨请求都不保证唯一。
原理流程
- 调用方不再直接构造,改为请求实例。
- 类型内部判断是否已创建;未创建则创建并保存引用。
- 后续调用一律返回同一引用。
- 并发场景下,第 2 步的「判断 + 创建」必须是原子的,否则会创建多个实例。
代码或图示
调用方 ──getInstance()──> [ 单例类型 ]
│ 私有构造器
│ 静态/全局唯一引用
└─ 首次调用时创建,之后复用
public final class IdGenerator {
private static final IdGenerator INSTANCE = new IdGenerator();
private final AtomicLong seq = new AtomicLong();
private IdGenerator() {}
public static IdGenerator getInstance() { return INSTANCE; }
public long next() { return seq.incrementAndGet(); }
}
常见误区
- 把单例当成「全局变量」的合法化包装:凡是需要共享访问就套单例,最终得到一堆隐式依赖。
- 认为单例能解决分布式唯一:多副本部署时每个进程各有一份,唯一性必须靠数据库唯一约束、分布式 ID 或协调服务。
- 认为单例一定线程安全:单例只保证实例唯一,实例内部的可变字段仍需自己保证并发安全。
追问
- 单例和「只创建一次」有什么区别?答:只创建一次是频次约束,单例还额外约束了访问路径与构造可见性;前者可以由工厂或容器实现。
- 无状态的服务需要单例吗?答:无状态对象多实例没有正确性问题,只有创建开销问题;容器通常默认单例只是为了省内存。
01.3.2.1-002 Java 单例的五种实现怎么选?
一句话结论
饿汉式最简单、类加载即创建;懒汉加锁最慢;双重检查锁(DCL)兼顾懒加载与性能但依赖 volatile;静态内部类用类初始化锁实现懒加载且写法干净;枚举最安全,天然防反射、防序列化破坏。
概念解释
- 饿汉式:
static final字段,类初始化阶段创建,由 JVM 保证线程安全。 - 懒汉式:方法级
synchronized,每次获取都加锁。 - DCL:先判空、再加锁、锁内再判空,配合
volatile。 - 静态内部类:外部类加载时不初始化内部类,首次访问
Holder.INSTANCE才触发内部类初始化。 - 枚举:
enum常量在 JVM 中唯一,序列化与反射都有特殊处理。
原理流程
- 判断实例创建成本:昂贵才值得懒加载,便宜就直接饿汉。
- 判断是否需要防反射/防序列化:需要则优先枚举。
- 判断是否需要延迟到首次使用:需要则静态内部类或 DCL。
- 团队历史代码沿用既有风格,避免同项目内多种写法混用。
代码或图示
// 1. 饿汉式
public final class A {
private static final A INSTANCE = new A();
private A() {}
public static A get() { return INSTANCE; }
}
// 2. 懒汉式(方法锁,性能最差)
public final class B {
private static B instance;
private B() {}
public static synchronized B get() {
if (instance == null) instance = new B();
return instance;
}
}
// 3. 静态内部类(推荐:懒加载 + 线程安全 + 写法简单)
public final class C {
private C() {}
private static final class Holder { static final C INSTANCE = new C(); }
public static C get() { return Holder.INSTANCE; }
}
// 4. 枚举(最安全)
public enum D {
INSTANCE;
public void doWork() { }
}
常见误区
- 懒汉式一定比饿汉式好:加锁的获取路径在高频调用下是实打实的开销,而饿汉只在类加载时付出一次。
- 静态内部类延迟了「类加载」就等于延迟了「对象创建」:内部类只有在首次主动使用时才初始化,这个结论成立,但外部类若通过反射提前触发内部类初始化则不再延迟。
- 单例类不加
final:子类可以继承并破坏唯一性,单例类型应声明final。
追问
- 枚举单例的缺点是什么?答:不能继承(枚举已隐式继承
Enum),启动时即创建、无法懒加载,对需要延迟初始化的重资源不合适。 - 静态内部类为什么线程安全?答:JVM 保证类的
<clinit>只执行一次,且多线程访问时会被同步阻塞,这是类初始化锁提供的语义。
01.3.2.1-003 双重检查锁为什么必须加 volatile?
一句话结论
new 不是原子操作,它包含「分配内存、初始化对象、把引用赋给变量」三步;没有 volatile 时编译器或 CPU 可能把引用赋值重排到初始化之前,另一线程在第一次判空时就会看到一个非 null 但字段尚未初始化的对象。
概念解释
- 重排来源:JIT 编译优化、处理器乱序执行、写缓冲区。
volatile的两个语义:保证可见性(写立即刷主存、读强制从主存取),禁止与该变量的读写发生特定重排。- DCL 的两个检查:外层避免每次加锁,内层避免重复创建。
原理流程
- 线程 T1 进入
getInstance(),发现instance == null。 - T1 获取类锁,再次判空,开始
new。 - 若发生重排,先把引用写入
instance,再初始化对象字段。 - 线程 T2 在第一次判空处看到
instance != null,直接返回,拿到半初始化对象。 - 加
volatile后,instance的写与对象初始化之间存在 happens-before 约束,T2 要么看到 null,要么看到完整对象。
代码或图示
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(); // volatile 写,禁止重排
}
}
}
return instance;
}
}
无 volatile 时可能的执行顺序:
1) 分配内存
2) instance = 内存地址 <-- 提前可见
3) 执行构造器初始化字段
另一线程在第 2 步后读取,得到「非 null 但字段为默认值」的对象
常见误区
- 只在字段上加
volatile而忘了内层判空:锁内不判空会导致多个线程排队后各自创建一次。 - 认为
synchronized能替代volatile:锁保证互斥,但不阻止锁外的第一次判空读到重排后的引用。 - 认为 DCL 在任何语言都一样:C#、Go、Rust 的内存模型与实现机制不同,不能照搬 Java 写法。
追问
- 静态内部类为什么不需要
volatile?答:它把实例创建放进类初始化流程,由 JVM 的类初始化锁统一保证可见性与原子性,不存在「引用先可见」的窗口。 - 现代 JVM 上 DCL 还值得写吗?答:能用静态内部类或枚举时优先用它们;DCL 主要用于实例创建昂贵且必须懒加载、又不能改类结构的场景。
01.3.2.1-004 Go 怎么实现单例?sync.Once 和包初始化有什么区别?
一句话结论
Go 用 sync.Once + 包级变量实现懒加载单例,Once.Do 保证函数只执行一次且对其他 goroutine 可见;包级 var x = newX() 在包初始化阶段执行,天然只执行一次但不是懒加载,且无法返回错误。
概念解释
sync.Once:内部用互斥锁加原子标志,保证Do的入参函数只执行一次,后续调用直接返回。- 包初始化:
import时按依赖顺序执行init()与包级变量初始化,单线程完成,天然安全。 - 惯用做法:需要懒加载或需要处理初始化错误时用
Once;初始化必然成功且成本可接受时直接用包级变量。
原理流程
- 定义包级
instance与once。 - 获取函数内调用
once.Do(func(){ instance = newX() })。 Do返回后,所有 goroutine 都能看到已完成初始化的instance。- 若初始化可能失败,用
once+err一起记录,或改用显式Init()返回 error。
代码或图示
package config
import "sync"
type Config struct {
DSN string
}
var (
instance *Config
once sync.Once
)
// 懒加载:首次调用时初始化,之后复用
func Get() *Config {
once.Do(func() {
instance = &Config{DSN: "postgres://localhost/app"}
})
return instance
}
// 包初始化:import 时即创建,天然单例但非懒加载
var defaultClient = NewClient(DefaultOptions())
常见误区
- 用
if instance == nil { instance = ... }裸判断:并发下会创建多个实例,且存在数据竞争。 - 在
Once.Do里执行可能阻塞很久的 IO:其他 goroutine 会被阻塞在Do上,首屏延迟被放大。 - 认为包级变量在所有场景都比
Once好:需要按配置动态初始化、需要返回错误、需要测试中重置时,包级变量很难处理。
追问
sync.Once能重试失败初始化吗?答:不能,Do执行过就算完成,即使函数内部失败;失败重试要自己加状态与锁。- Go 里怎么在测试中替换单例?答:把依赖改成接口并由调用方注入,或提供
resetForTest这类仅在测试构建标签下可用的函数,不推荐直接改包级变量。
01.3.2.1-005 Python 单例有哪些写法?GIL 能保证线程安全吗?
一句话结论
Python 最常用的单例是「模块级实例」——模块只执行一次,天然进程内唯一;需要类级单例时可用 __new__、装饰器或元类,但 __new__ 的判断创建过程仍需显式加锁,GIL 只保证单条字节码原子,不保证「判断 + 创建」整体原子。
概念解释
- 模块级实例:
config = Config()写在模块顶层,import 机制保证模块只执行一次。 __new__方案:拦截实例创建,把结果缓存到类属性。- 装饰器方案:用闭包缓存实例,返回包装函数。
- 元类方案:在
__call__中缓存,对继承与子类更统一。
原理流程
- 优先用模块级实例,简单且符合 Python 惯例。
- 需要类语义(可继承、可类型标注)时用
__new__或元类。 - 多线程创建路径加
threading.Lock,采用双重检查。 - 多进程场景改用进程间共享机制,模块级单例在子进程中会各自重建。
代码或图示
# 1. 模块级实例:Python 最推荐的「单例」
# config.py
class Config:
def __init__(self) -> None:
self.dsn = "postgres://localhost/app"
config = Config()
# 2. __new__ + 锁
import threading
class Config:
_instance = None
_lock = threading.Lock()
def __new__(cls, *args, **kwargs):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self) -> None: # 注意:每次调用都会重新执行
self.dsn = "postgres://localhost/app"
# 3. 装饰器
def singleton(cls):
instances = {}
def get(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get
@singleton
class Registry:
pass
常见误区
- 以为 GIL 让
__new__天然线程安全:GIL 可能在字节码之间切换,两个线程仍可能同时通过if cls._instance is None。 - 忘记
__init__会重复执行:__new__返回同一实例后,__init__每次调用都会再跑一遍,重资源初始化要加保护。 - 把 Python 的
@decorator语法等同于装饰器模式:函数装饰器是语法糖,能实现包装语义,但不等于 GoF 的类组合结构。
追问
- 多线程下模块级实例安全吗?答:模块导入本身由 import 锁保护,实例创建只发生一次;但实例内部的可变状态仍需自己加锁。
- 多进程怎么共享单例?答:单例无法跨进程共享,需改用共享内存、Redis、数据库或 manager 进程。
01.3.2.1-006 PHP 单例在 FPM 下真的「唯一」吗?
一句话结论
不唯一。PHP 的静态属性生命周期跟随「单次请求」而非「整个服务进程」,在传统 FPM 模型下每个请求都会重新构建单例;只有常驻进程模型(如常驻 worker、Swoole 类扩展)才可能跨请求复用,且要自己处理状态清理。
概念解释
- FPM 模型:master 管理多个 worker 进程,每个 worker 处理请求后清理请求级资源,用户态静态属性不跨请求保留。
- 常驻模型:进程长期存活,静态属性与容器实例会跨请求复用。
- 因此 PHP 单例的实际语义是「单次请求内唯一」,用于避免同一次请求内重复构造,而不是跨请求缓存。
原理流程
- 请求进入,自动加载类,静态属性初始化为 null。
- 首次
getInstance()创建实例。 - 同请求内后续调用复用该实例。
- 请求结束,请求级内存释放,下次请求重新开始。
代码或图示
final class Config
{
private static ?self $instance = null;
private function __construct() {}
public static function getInstance(): self
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
private function __clone() {}
public function __wakeup(): void
{
throw new \RuntimeException('Cannot unserialize a singleton.');
}
}
FPM:请求 A → 单例创建 → 请求结束销毁 → 请求 B → 重新创建
常驻 worker:进程启动 → 单例创建 → 跨请求复用(需自行清理请求态字段)
常见误区
- 用 PHP 单例做跨请求缓存:请求结束即丢失,起不到缓存作用,跨请求缓存应该用 APCu、Redis 等。
- 不封
__clone与__wakeup:克隆与反序列化都能绕过私有构造器产生第二个实例。 - 在常驻模型里复用单例却不清理请求态:上一个请求的用户上下文会串到下一个请求,这是典型的串数据事故。
追问
- PHP 里怎么实现跨请求共享?答:用进程外的共享存储(Redis、数据库)或 APCu 这类共享内存扩展;单例本身做不到。
- 常驻模型下单例要注意什么?答:区分「进程级无状态服务」与「请求级状态」,请求级字段必须在请求结束时重置,或改用请求作用域的容器绑定。
01.3.2.1-007 C# 单例为什么推荐 Lazy<T>?
一句话结论
Lazy<T> 把「延迟初始化 + 线程安全」交给运行时实现,默认 LazyThreadSafetyMode.ExecutionAndPublication 保证只有一个线程执行工厂方法、其他线程等待结果,比手写 DCL 更不容易出错。
概念解释
static readonly+ 内联初始化:类型加载时创建,等价于饿汉式。Lazy<T>:首次访问.Value时执行工厂方法,默认线程安全。- 容器注册:
AddSingleton<T>()由 DI 容器管理生命周期,是 ASP.NET Core 的推荐方式。
原理流程
- 无状态、初始化便宜:
static readonly字段即可。 - 初始化昂贵或需要延迟:
Lazy<T>。 - 需要可替换、可测试:注册到 DI 容器,由容器注入。
- 需要跨请求单例:
AddSingleton;需要每请求一个:AddScoped。
代码或图示
// 1. static readonly:类型加载时创建
public sealed class A
{
public static readonly A Instance = new A();
private A() { }
}
// 2. Lazy<T>:首次访问时创建,默认线程安全
public sealed class B
{
private static readonly Lazy<B> _lazy = new(() => new B());
private B() { }
public static B Instance => _lazy.Value;
}
// 3. ASP.NET Core DI:由容器管理生命周期
builder.Services.AddSingleton<IConfigProvider, ConfigProvider>();
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
常见误区
- 用
Lazy<T>却传LazyThreadSafetyMode.None:多线程下会重复执行工厂方法,等于放弃线程安全。 - 把
AddSingleton注册的服务当无状态用:单例服务会被所有请求共享,内部可变字段必须线程安全。 - 在
Lazy<T>工厂里做阻塞 IO:首次访问会阻塞所有并发访问者。
追问
Lazy<T>工厂抛异常后会怎样?答:默认模式下异常会被缓存,后续访问继续抛出同一异常,不会自动重试。AddSingleton和 GoF 单例的区别?答:前者由容器按注册类型提供唯一实例、可被替换与 mock;后者把唯一性硬编码在类型内部。
01.3.2.1-008 TypeScript/JavaScript 的单例为什么可能不止一个?
一句话结论
ES Module 规范保证一个模块在同一模块图里只求值一次,export const instance = new X() 因此是天然单例;但模块缓存以「解析后的模块标识」为键,打包拆分、多份依赖副本、不同 realm(如 iframe、worker)都会产生多个实例。
概念解释
- ESM:模块只求值一次,导出绑定共享。
- CJS:
require按解析后的文件路径缓存,同一路径多次 require 返回同一module.exports。 - 多副本来源:同一库的不同版本被分别打包、monorepo 中软链接导致路径不同、动态
import()与静态import混用、打包工具生成多个 chunk。 - 热更新:开发期 HMR 会重新执行模块,模块级状态被重置。
原理流程
- 定义模块级实例并导出。
- 所有使用方
import同一模块路径。 - 构建工具保证该模块只进入一份 chunk,或显式配置共享依赖。
- 需要跨模块图共享时,挂到全局对象(
globalThis)作为兜底,但要接受污染全局的代价。
代码或图示
// config.ts —— 模块级单例,最常见的 JS/TS 写法
class Config {
private static instance: Config | null = null;
private constructor(public readonly dsn: string) {}
static get instance(): Config {
if (this.instance === null) {
this.instance = new Config("postgres://localhost/app");
}
return this.instance;
}
}
export const config = Config.instance;
// 多副本兜底:挂到 globalThis(谨慎使用)
const KEY = Symbol.for("app.config");
const g = globalThis as Record<symbol, unknown>;
export const config = (g[KEY] ??= Config.instance) as Config;
常见误区
- 认为
private constructor能阻止第二个实例:运行时仍可通过as any或反射式访问绕过,它只提供编译期约束。 - 认为 npm 依赖去重一定生效:版本不一致或打包配置不同都会让同一模块出现两份。
- 在 SSR 里把单例当请求级缓存:Node 服务端模块常驻,单例会在请求间共享,用户态数据会串。
追问
- Node 服务端单例要注意什么?答:单例是进程级的,多实例部署时每进程一份;请求相关状态不能放进单例,应该放在请求上下文。
- 前端为什么常用模块级单例而不是类单例?答:模块缓存已经提供了唯一性,类单例额外增加一层间接,收益有限。
01.3.2.1-009 Rust 为什么很难写出经典单例?
一句话结论
Rust 没有「类静态可变字段」这种随意可用的全局状态,全局可变必须通过 static + 内部可变性 + 同步原语显式声明;OnceLock 提供一次性初始化的全局值,但不可变借用与可变借用规则要求用 Mutex/RwLock 包装可变数据。
概念解释
static:全局变量,要求类型实现Sync,且必须是编译期可构造的常量表达式。OnceLock:只能初始化一次的容器,get_or_init并发安全。Mutex/RwLock:给全局可变数据提供运行时同步。- 所有权:单例返回
&'static T,调用方只能借用,不能随意取走所有权。
原理流程
- 不可变全局配置:
static CONFIG: OnceLock<Config>。 - 可变全局注册表:
static REGISTRY: OnceLock<RwLock<HashMap<..>>>。 - 访问时先
get_or_init拿到引用,再按需read()/write()加锁。 - 需要「每个线程一个」时改用
thread_local!,而不是全局单例。
代码或图示
use std::sync::OnceLock;
#[derive(Debug)]
struct Config {
dsn: String,
}
static CONFIG: OnceLock<Config> = OnceLock::new();
fn config() -> &'static Config {
CONFIG.get_or_init(|| Config {
dsn: "postgres://localhost/app".to_string(),
})
}
use std::collections::HashMap;
use std::sync::{OnceLock, RwLock};
static REGISTRY: OnceLock<RwLock<HashMap<String, String>>> = OnceLock::new();
fn registry() -> &'static RwLock<HashMap<String, String>> {
REGISTRY.get_or_init(|| RwLock::new(HashMap::new()))
}
fn set(key: &str, value: &str) {
registry().write().unwrap().insert(key.to_string(), value.to_string());
}
常见误区
- 以为
static mut是可用方案:Rust 2024 起对static mut引用有更严格的限制,正确做法是OnceLock+ 同步原语,而不是裸static mut。 - 在单例里返回
&mut:全局可变借用无法静态证明安全,必须走锁或原子类型。 - 用
lazy_static!/once_cell却忽略版本演进:标准库已提供OnceLock(稳定版本以官方文档为准),新项目优先标准库。
追问
- Rust 单例为什么不需要「防反射」?答:Rust 没有运行时反射创建实例的通用机制,私有构造器在编译期就是硬约束。
OnceLock::set第二次调用会怎样?答:返回Err,原值保持不变,不会覆盖,这天然保证了唯一性。
01.3.2.1-010 Spring、ASP.NET Core、Laravel 里的「单例」是什么?
一句话结论
框架里的「单例」是容器作用域,不是 GoF 的类内单例:Spring 的 singleton scope、ASP.NET Core 的 AddSingleton、Laravel 的 singleton 绑定都由容器负责唯一性与注入,类型本身仍是普通类,可被替换、可被 mock。
概念解释
- Spring:
@Component默认singleton作用域,容器内一个 Bean;@Scope("prototype")每次注入新实例。 - ASP.NET Core:
AddSingleton(进程内一个)、AddScoped(每请求一个)、AddTransient(每次解析一个)。 - Laravel:
$this->app->singleton(Interface::class, Impl::class),容器内共享一个解析结果。 - Gin:没有内置 DI 容器,通常用 handler 结构体字段注入或包级
sync.Once。
原理流程
- 类型声明为普通类,构造器可以是公开的。
- 在容器启动阶段注册抽象到实现的映射与作用域。
- 解析时容器按作用域决定复用还是新建。
- 需要替换实现时只改注册点,不改调用方。
代码或图示
// Spring:默认 singleton 作用域
@Component
public class ConfigProvider {
private final Map<String, String> cache = new ConcurrentHashMap<>();
public String get(String key) { return cache.get(key); }
}
// ASP.NET Core:容器作用域
builder.Services.AddSingleton<IConfigProvider, ConfigProvider>();
// Laravel:容器单例绑定
$this->app->singleton(ConfigProvider::class, function ($app) {
return new ConfigProvider($app['config']);
});
// Gin:无容器,包级初始化 + 注入 handler
var cfg = loadConfig()
func NewHandler(c *Config) *Handler { return &Handler{cfg: c} }
常见误区
- 把容器单例当线程安全:容器只保证实例唯一,Bean 内部共享可变字段仍需并发保护,Spring 单例 Bean 应尽量无状态。
- 在单例 Bean 里存请求级数据:请求 A 的数据会被请求 B 读到,典型串数据。
- 以为
prototype能解决所有状态问题:每次新建会增加对象数量与初始化成本,应按状态归属选择作用域。
追问
- Spring 单例 Bean 和 GoF 单例的本质区别?答:唯一性由容器管理且可配置,实例可被代理、替换与销毁;GoF 单例把唯一性写死在类型内部。
- 循环依赖在单例 Bean 上怎么暴露?答:单例在启动期创建,循环依赖会在容器启动时报错;原型作用域可能延迟到调用时才暴露,反而更难排查。
01.3.2.1-011 哪些方式会破坏单例?分布式场景还成立吗?
一句话结论
反射调用私有构造器、反序列化、克隆、类加载器隔离、多进程/多副本部署都会产生第二个「单例」;单例只在单进程内成立,分布式唯一性必须由外部机制(唯一约束、分布式锁、单点分配)保证。
概念解释
- 反射:
setAccessible(true)后调用私有构造器(Java)。 - 序列化:反序列化默认走构造器之外的对象创建路径。
- 克隆:
clone()绕过构造器。 - 类加载器:同一 class 文件被不同 ClassLoader 加载,得到不同 Class 与不同静态字段。
- 多进程:FPM worker、gunicorn worker、JVM 多实例、容器多副本。
原理流程
- 枚举单例天然免疫反射与序列化(Java)。
- 普通单例在构造器内加「已初始化」校验并抛异常。
- 实现
readResolve()返回既有实例,封clone()与__wakeup()。 - 跨进程唯一性改用数据库唯一索引、Redis 分布式锁或集中式 ID 分配。
代码或图示
// 防反射与反序列化的普通单例
public final class SafeSingleton implements Serializable {
private static final SafeSingleton INSTANCE = new SafeSingleton();
private static boolean initialized = false;
private SafeSingleton() {
synchronized (SafeSingleton.class) {
if (initialized) throw new IllegalStateException("Use INSTANCE");
initialized = true;
}
}
public static SafeSingleton getInstance() { return INSTANCE; }
private Object readResolve() { return INSTANCE; }
@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}
单进程内:类加载器 A 一份 + 类加载器 B 一份 → 两个「单例」
多副本:Pod1 一份 + Pod2 一份 → 两个「单例」
分布式唯一:数据库唯一索引 / Redis SETNX / 集中式 ID 服务
常见误区
- 以为加了
synchronized就防住所有破坏:锁只解决并发创建,不解决反射、序列化与类加载器隔离。 - 用单例实现「全局唯一订单号」:多副本下必然重复,必须用数据库序列、Snowflake 或号段服务。
- 在测试里直接改单例内部状态:测试间互相污染,且掩盖了真实依赖关系。
追问
- 枚举单例为什么防反射?答:
Constructor.newInstance对枚举类型有专门校验,直接抛异常,不允许反射创建枚举实例。 - 分布式场景怎么复用单例思想?答:把「唯一实例」换成「唯一协调者」,用选主、租约或分布式锁保证同一时刻只有一个角色在提供服务。
01.3.2.1-012 单例、静态工具类、依赖注入怎么取舍?
一句话结论
无状态纯函数用静态工具类;需要持有状态、实现接口、被替换或被代理时用依赖注入(容器单例);只有在框架与语言都不提供容器、且确实需要进程内唯一有状态对象时,才手写 GoF 单例。
概念解释
- 静态工具类:全是静态方法,无实例、无状态、不能被实现接口,测试时无法替换。
- 依赖注入:调用方声明依赖抽象,容器注入实现,作用域可配置,测试可传替身。
- GoF 单例:类型内部硬编码唯一实例,调用方通过静态方法获取,隐式依赖。
原理流程
- 判断是否需要状态:无状态优先静态工具类或普通函数。
- 判断是否需要替换:需要替换(测试、灰度、多实现)走依赖注入。
- 判断是否有容器:有容器就用容器单例,不要手写。
- 无容器且必须唯一有状态:手写单例,并把获取入口收敛到一处。
代码或图示
静态工具类:StringUtils.isBlank(s) 无状态、不可注入、不可 mock
依赖注入: class Svc(private Repo r) 可替换、可 mock、作用域由容器管
GoF 单例: Config.getInstance() 隐式全局依赖、难替换、难并行测试
// 依赖注入:推荐形态
public class OrderService {
private final OrderRepository repo; // 抽象依赖,由容器注入
public OrderService(OrderRepository repo) { this.repo = repo; }
}
常见误区
- 在业务代码里到处
getInstance():等于引入全局变量,单测必须准备全局状态,测试隔离变差。 - 用静态工具类持有可变状态:静态可变字段是并发与测试污染的源头。
- 认为依赖注入一定要框架:手写构造函数注入同样成立,容器只是自动化装配。
追问
- 单例怎么让测试可替换?答:把单例包装成接口,通过构造器注入;或在测试中使用可重置的测试替身,避免直接依赖全局静态入口。
- 单例和对象池的区别?答:单例强调「唯一一个」,对象池是「一组可借用归还」,后者用于复用昂贵资源并限制并发。
跨语言差异对照
| 语言 | 惯用实现 | 唯一性由谁保证 | 主要陷阱 |
|---|---|---|---|
| Java | 枚举 / 静态内部类 / DCL + volatile |
JVM 类初始化锁、volatile 内存语义 |
反射、序列化、多 ClassLoader |
| Go | sync.Once + 包级变量 |
Once 内部锁与原子标志 |
包级变量无法返回错误、测试难重置 |
| Python | 模块级实例;__new__/装饰器/元类 |
import 机制;显式 threading.Lock |
__init__ 重复执行、GIL 不等于原子 |
| PHP | 静态属性 + 私有构造器 | 请求级生命周期 | FPM 下不跨请求、常驻模型状态串号 |
| C#/.NET | static readonly、Lazy<T>、DI AddSingleton |
CLR 类型初始化、Lazy 同步、容器作用域 |
LazyThreadSafetyMode.None、单例服务状态 |
| TypeScript/JS | 模块级 export const |
模块系统缓存 | 多副本打包、HMR 重置、SSR 跨请求共享 |
| Rust | OnceLock + Mutex/RwLock |
OnceLock 的一次性初始化 |
全局可变借用、static mut 误用 |
跨语言差异
- Go 没有继承与静态成员,单例只能靠包级变量加
sync.Once,唯一性来自并发原语而不是类型系统。 - Rust 不允许随意全局可变状态,单例必须显式声明同步方式,「唯一 + 可变」的代价写在类型上。
- C# 的类型初始化由 CLR 保证,
static readonly就是最简饿汉;Lazy<T>把延迟与线程安全做成库能力。 - TypeScript 的单例本质是模块系统特性,类单例只是补充;判断唯一性要看模块图而不是类。
- Python 与 PHP 的单例都受运行时模型约束:Python 受 import 机制与 GIL 影响,PHP 受请求生命周期影响。
- Java 是唯一需要专门讨论「反射与序列化破坏」的语言,因为它的运行时反射能力最强。
待整理清单
- [ ] 补充 Kotlin
object与 Scalaobject的单例语义对照 - [ ] 补充单例在 GraalVM native image、Android 多进程下的行为
- [ ] 补充各语言单例的基准测试数据(本机实测后填入)
- [ ] 补充 Swoole/Octane 常驻模型下单例状态清理的实际案例