罗罗编程学习记录
本页内容 展开查看

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、跨请求都不保证唯一。

原理流程

  1. 调用方不再直接构造,改为请求实例。
  2. 类型内部判断是否已创建;未创建则创建并保存引用。
  3. 后续调用一律返回同一引用。
  4. 并发场景下,第 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 中唯一,序列化与反射都有特殊处理。

原理流程

  1. 判断实例创建成本:昂贵才值得懒加载,便宜就直接饿汉。
  2. 判断是否需要防反射/防序列化:需要则优先枚举。
  3. 判断是否需要延迟到首次使用:需要则静态内部类或 DCL。
  4. 团队历史代码沿用既有风格,避免同项目内多种写法混用。

代码或图示

// 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 的两个检查:外层避免每次加锁,内层避免重复创建。

原理流程

  1. 线程 T1 进入 getInstance(),发现 instance == null。
  2. T1 获取类锁,再次判空,开始 new。
  3. 若发生重排,先把引用写入 instance,再初始化对象字段。
  4. 线程 T2 在第一次判空处看到 instance != null,直接返回,拿到半初始化对象。
  5. 加 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;初始化必然成功且成本可接受时直接用包级变量。

原理流程

  1. 定义包级 instance 与 once。
  2. 获取函数内调用 once.Do(func(){ instance = newX() })。
  3. Do 返回后,所有 goroutine 都能看到已完成初始化的 instance。
  4. 若初始化可能失败,用 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__ 中缓存,对继承与子类更统一。

原理流程

  1. 优先用模块级实例,简单且符合 Python 惯例。
  2. 需要类语义(可继承、可类型标注)时用 __new__ 或元类。
  3. 多线程创建路径加 threading.Lock,采用双重检查。
  4. 多进程场景改用进程间共享机制,模块级单例在子进程中会各自重建。

代码或图示

# 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 单例的实际语义是「单次请求内唯一」,用于避免同一次请求内重复构造,而不是跨请求缓存。

原理流程

  1. 请求进入,自动加载类,静态属性初始化为 null。
  2. 首次 getInstance() 创建实例。
  3. 同请求内后续调用复用该实例。
  4. 请求结束,请求级内存释放,下次请求重新开始。

代码或图示

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 的推荐方式。

原理流程

  1. 无状态、初始化便宜:static readonly 字段即可。
  2. 初始化昂贵或需要延迟:Lazy<T>。
  3. 需要可替换、可测试:注册到 DI 容器,由容器注入。
  4. 需要跨请求单例: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 会重新执行模块,模块级状态被重置。

原理流程

  1. 定义模块级实例并导出。
  2. 所有使用方 import 同一模块路径。
  3. 构建工具保证该模块只进入一份 chunk,或显式配置共享依赖。
  4. 需要跨模块图共享时,挂到全局对象(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,调用方只能借用,不能随意取走所有权。

原理流程

  1. 不可变全局配置:static CONFIG: OnceLock<Config>。
  2. 可变全局注册表:static REGISTRY: OnceLock<RwLock<HashMap<..>>>。
  3. 访问时先 get_or_init 拿到引用,再按需 read()/write() 加锁。
  4. 需要「每个线程一个」时改用 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。

原理流程

  1. 类型声明为普通类,构造器可以是公开的。
  2. 在容器启动阶段注册抽象到实现的映射与作用域。
  3. 解析时容器按作用域决定复用还是新建。
  4. 需要替换实现时只改注册点,不改调用方。

代码或图示

// 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 多实例、容器多副本。

原理流程

  1. 枚举单例天然免疫反射与序列化(Java)。
  2. 普通单例在构造器内加「已初始化」校验并抛异常。
  3. 实现 readResolve() 返回既有实例,封 clone() 与 __wakeup()。
  4. 跨进程唯一性改用数据库唯一索引、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 单例:类型内部硬编码唯一实例,调用方通过静态方法获取,隐式依赖。

原理流程

  1. 判断是否需要状态:无状态优先静态工具类或普通函数。
  2. 判断是否需要替换:需要替换(测试、灰度、多实现)走依赖注入。
  3. 判断是否有容器:有容器就用容器单例,不要手写。
  4. 无容器且必须唯一有状态:手写单例,并把获取入口收敛到一处。

代码或图示

静态工具类: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 与 Scala object 的单例语义对照
  • [ ] 补充单例在 GraalVM native image、Android 多进程下的行为
  • [ ] 补充各语言单例的基准测试数据(本机实测后填入)
  • [ ] 补充 Swoole/Octane 常驻模型下单例状态清理的实际案例