sync.Once源码解析：Go并发编程中的单例模式与懒加载实战

在 Go 的并发原语中，若要评选最经典、最优雅且最常被提及的组件，sync.Once 一定榜上有名。它仅用二十余行代码，便精妙地诠释了 Go 的并发设计哲学：极致简单、零成本快路径、内存顺序正确以及 panic 安全。今天，我们就来彻底剖析它的实现。

核心数据结构

首先看最核心的结构体定义（摘自 src/sync/once.go）：

type Once struct {
    done uint32 // atomic access
    m    Mutex
}

结构极其精简，仅包含两个字段：

• done：uint32 类型，通过原子操作访问，标识初始化函数是否已被执行。
  • 0 表示未执行。
  • 1 表示已执行（无论成功还是 panic）。
• m：一个普通的互斥锁，用于慢路径下的串行化控制。

唯一的对外 API：Do()

sync.Once 仅对外暴露一个方法：

func (o *Once) Do(f func())

其语义是：无论有多少个 goroutine 并发调用，传入的函数 f 都只会被真正地执行一次。 这对于实现单例模式、懒加载等场景至关重要。

我们直接查看其在 Go 1.21+ 版本中的实现（核心逻辑自 Go 1.19 以来已非常稳定）：

func (o *Once) Do(f func()) {
    // Fast path: 如果 done 已经为 1，直接返回
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow path: 可能需要执行 f
    o.doSlow(f)
}

这是典型的双检锁（Double-Checked Locking, DCL）思想，但比传统实现更为简洁安全。真正的核心逻辑藏在 doSlow 方法中：

func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()

    // 第二次检查（在持有锁的情况下）
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        // 这里才是真正执行用户传入的 f
        f()
    }
    // 如果进来时 done 已经为 1，说明其他协程已执行完毕，直接返回
}

让我们拆解其精妙之处：

1. 无锁快路径：首次调用 atomic.LoadUint32 是无锁操作，速度极快。一旦初始化完成，所有后续调用都直接命中此路径并立即返回。
2. 有锁慢路径：当 done 为 0 时，才会进入需要加锁的慢路径。
3. 二次检查：在持有互斥锁后，再次检查 done 状态。这是为了防止多个同时进入慢路径的 goroutine 重复执行 f。
4. 唯一执行：只有通过第二次检查（done == 0）的那个 goroutine 有资格调用 f()。
5. defer 确保原子写：通过 defer atomic.StoreUint32(&o.done, 1) 确保无论 f() 是正常返回还是发生 panic，done 标志位都会被置为 1。这是一种关于源码分析的经典安全模式。

为什么 panic 后也要设置 done=1？

这是一个关键的设计决策。试想如果 f() 执行时发生 panic：

• 若不设置 done 为 1：后续所有 goroutine 会认为初始化未完成，反复尝试执行 f()，导致反复 panic，引发雪崩。
• 若设置 done 为 1：后续 goroutine 感知到“已执行”，便不会再调用 f()，从而将 panic 隔离在首次调用中。

因此，Go 的设计哲学是：“宁可只执行一次（哪怕是失败的），也绝不再重试”。这与某些其他语言中单例初始化的重试逻辑不同。

性能剖析：快路径 vs 慢路径

我们来分析 sync.Once.Do() 在不同场景下的开销：

场景	路径	atomic 操作	加锁	执行 f()	大致开销（现代 CPU）
第 1 个到达的 goroutine	慢路径	1 Load + 1 Store	是	是	~几十纳秒
第 2~n 个到达（done=0 时）	慢路径	1 Load	是	否	~10-30 纳秒
done=1 之后的任意调用	快路径	1 Load	否	否	~2-5 纳秒

可见，在绝大多数场景（即初始化完成后），调用开销仅为一次原子读操作，性能极高。这也是 sync.Once 被广泛用于单例模式、懒加载配置、数据库连接池初始化、全局日志对象初始化等场景的原因。

常见错误用法（面试高频点）

1. 拷贝 sync.Once

   var globalOnce sync.Once
   
   func bad() {
       once := globalOnce // 错误！复制了 sync.Once！
       once.Do(initFunc)  // 此调用不会生效！
   }

   sync.Once 在首次使用后禁止被复制。 这一点在其官方文档中有明确说明。

2. 在 Do 内部嵌套调用另一个 Once.Do
   这可能导致难以排查的死锁问题，需要特别小心。

3. 误解 panic 后的行为
   如前所述，panic 后 done 仍为 1，后续调用不会再执行 f()。如果业务逻辑要求失败后重试，那么 sync.Once 并非合适的选择。

Go 1.21+ 新增：OnceFunc（彩蛋）

从 Go 1.21 开始，标准库新增了一个辅助函数：

func OnceFunc(f func()) func()

它返回一个新的函数，调用这个新函数只会执行一次原始函数 f。这提供了一种更函数式、更便捷的使用方式。

典型用法：

var heavyInit = sync.OnceFunc(func() {
    // 一些耗时的一次性初始化逻辑
})

func handler() {
    heavyInit() // 无论被调用多少次，初始化逻辑只执行一次
    // 后续业务逻辑...
}

总结：为何 sync.Once 如此经典？

1. 极简 API：仅有一个 Do 方法。
2. 极致的快路径：初始化后仅需一次原子读，近乎零开销。
3. 正确的慢路径：经典 DCL 配合 Mutex，保证并发安全。
4. Panic 安全：通过 defer 确保 done 标志位一定会被设置，防止 panic 扩散。
5. 内存顺序保证：原子操作与互斥锁的组合提供了必要的 Release/Acquire 内存序语义。
6. 代码极简：实现短小精悍，却完美解决了高并发下一次性初始化这一通用痛点。

简而言之，sync.Once 是 Go 并发编程中 “少即是多” 设计哲学的典范。深入理解其源码，不仅有助于在面试中应对自如，更能让我们在日常开发中写出更健壮、高效的并发代码。希望这篇解析能为你带来新的启发，也欢迎在云栈社区与更多开发者交流 Go 语言的学习心得。