当前位置：首页 > Go > 正文

Go语言并发控制利器：sync.Once 的实现原理详解（小白也能看懂的 Go sync.Once 源码剖析）

主机测评网
Go
2025-12-06
359

在 Go语言 的并发编程中，我们经常会遇到需要确保某段代码在整个程序生命周期中只执行一次的场景。例如：初始化配置、单例模式、加载资源等。这时候，sync.Once 就派上了大用场。

本文将深入浅出地讲解 sync.Once 的实现原理，帮助你理解它是如何做到线程安全（即并发安全）且高效地只执行一次操作的。即使你是 Go 语言的新手，也能轻松掌握！

什么是 sync.Once？

sync.Once 是 Go 标准库 sync 包中的一个结构体，它提供了一种机制，保证某个函数在整个程序运行期间只被调用一次，无论有多少个 goroutine 同时尝试调用它。

它的使用非常简单：

package mainimport (    "fmt"    "sync")var once sync.Oncefunc initConfig() {    fmt.Println("配置已初始化！")}func main() {    var wg sync.WaitGroup    for i := 0; i < 5; i++ {        wg.Add(1)        go func() {            defer wg.Done()            once.Do(initConfig) // 只会打印一次“配置已初始化！”        }()    }    wg.Wait()}

运行上述代码，你会发现无论启动多少个 goroutine，initConfig 函数只会被执行一次。这就是 sync.Once 的魔力！

Go语言并发控制利器：sync.Once 的实现原理详解（小白也能看懂的 Go sync.Once 源码剖析） Go语言实现原理并发安全第1张

sync.Once 的内部结构

要理解其实现原理，我们先看看 sync.Once 在源码中是如何定义的（Go 1.20+ 版本）：

type Once struct {    done uint32    m    Mutex}

可以看到，Once 结构体包含两个字段：

done：一个 uint32 类型的原子变量，用于标记函数是否已经执行过（0 表示未执行，1 表示已执行）。
m：一个互斥锁（Mutex），用于在多个 goroutine 竞争执行时提供同步保护。

Do 方法的实现原理

Do 是 sync.Once 唯一的公开方法，其核心逻辑如下（简化版）：

func (o *Once) Do(f func()) {    if atomic.LoadUint32(&o.done) == 0 {        o.doSlow(f)    }}func (o *Once) doSlow(f func()) {    o.m.Lock()    defer o.m.Unlock()    if o.done == 0 {        defer atomic.StoreUint32(&o.done, 1)        f()    }}

让我们一步步拆解这个过程：

快速路径（Fast Path）：首先通过 atomic.LoadUint32 原子读取 done 的值。如果已经是 1，说明函数已执行过，直接返回，不加锁，性能极高。
慢速路径（Slow Path）：如果 done 是 0，则进入 doSlow 方法。这里会先获取互斥锁，防止多个 goroutine 同时进入。
双重检查（Double-Check）：在加锁后再次检查 done 是否为 0。这是为了防止在等待锁的过程中，其他 goroutine 已经完成了初始化。
执行并标记：如果确实未执行，则调用传入的函数 f()，并在完成后通过 atomic.StoreUint32 将 done 设为 1。

这种“先原子读 + 再加锁 + 双重检查”的设计，既保证了 并发安全，又避免了每次调用都加锁的开销，是典型的高性能并发控制模式。

为什么需要 sync.Once？

你可能会问：为什么不直接用全局变量加锁来实现？比如：

var initialized boolvar mu sync.Mutexfunc initConfig() {    mu.Lock()    defer mu.Unlock()    if !initialized {        // 执行初始化        initialized = true    }}

这样写虽然也能工作，但存在两个问题：