「Go语言面试题」20 -Go并发编程：sync.Once 的底层机制与最佳实践
引言
“这个初始化操作只需要执行一次，但在多 goroutine 环境下怎么办？” 相信每个 Go 开发者都遇到过这样的场景。从配置文件加载到数据库连接池初始化，从单例模式实现到昂贵资源的懒加载 - 这些都需要确保某个操作在多并发环境下只执行一次。Go 语言标准库中的 sync.Once 就是这个问题的优雅解决方案。
今天，我们就来深入剖析 sync.Once 的实现原理，看看这个看似简单的类型背后隐藏着怎样的并发编程智慧。
什么是 sync.Once？
sync.Once 是 Go 标准库 sync 包中的一个结构体，它保证某个函数只被执行一次，无论在多少个 goroutine 中调用，也无论调用多少次。
基本用法非常简单：
var once sync.Once
var config map[string]string
func loadConfig() {
// 模拟昂贵的初始化操作
config = make(map[string]string)
config["host"] = "localhost"
config["port"] = "8080"
fmt.Println("Configuration loaded")
}
func GetConfig() map[string]string {
once.Do(loadConfig) // 确保 loadConfig 只执行一次
return config
}
深入源码：sync.Once 的实现原理
让我们打开 Go 源码，看看 sync.Once 的真实面貌：
// sync/once.go 中的实现
type Once struct {
done uint32 // 关键标志位
m Mutex // 互斥锁
}
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.Mutex.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}
看，整个核心实现只有 20 行代码！ 但这 20 行代码却蕴含着深刻的并发编程思想。
双重检查锁定模式（Double-Checked Locking）
sync.Once 采用了经典的双重检查锁定模式：
第一重检查：原子读（快速路径）
if atomic.LoadUint32(&o.done) == 0 {
o.doSlow(f)
}
使用 atomic.LoadUint32 进行无锁的原子读操作，如果 done 标志已经为 1，直接返回，避免锁竞争。
第二重检查：互斥锁保护（慢速路径）
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
获取互斥锁后再次检查，确保在锁保护下的绝对安全。
为什么需要双重检查？
这种设计巧妙地平衡了性能和正确性：
- 性能优化：99.9% 的情况下，第一次检查就能快速返回，避免锁开销
- 线程安全：第二次检查在互斥锁保护下，确保真正的单次执行
- 内存屏障：
atomic.StoreUint32确保写入操作对其他 goroutine 可见
内存模型与可见性
这里有一个关键细节：为什么使用 atomic 包而不是直接读写？
// 错误做法：直接读写可能遇到可见性问题
if o.done == 0 { // 可能读到旧值
o.m.Lock()
if o.done == 0 {
o.done = 1 // 可能其他 goroutine 看不到这个写入
f()
}
o.m.Unlock()
}
atomic 包保证了内存操作的顺序性和可见性，确保：
- 在
f()执行完成后，done = 1的写入对所有 goroutine 可见 - 不会发生指令重排导致的诡异 bug
实战案例：单例模式实现
让我们看一个完整的单例模式示例：
type Database struct {
connection string
}
var (
instance *Database
once sync.Once
)
func GetDatabase() *Database {
once.Do(func() {
fmt.Println("Creating database instance...")
instance = &Database{connection: "mysql://user:pass@localhost/db"}
// 模拟昂贵的连接初始化
time.Sleep(100 * time.Millisecond)
})
return instance
}
func main() {
// 多个 goroutine 同时获取单例
for i := 0; i < 5; i++ {
go func(id int) {
db := GetDatabase()
fmt.Printf("Goroutine %d got instance: %p\n", id, db)
}(i)
}
time.Sleep(time.Second)
// 输出：Creating database instance... 只打印一次
}
常见陷阱与注意事项
1. 错误处理
Once.Do 不提供错误处理机制，如果初始化函数可能失败，需要自行处理：
var initError error
var once sync.Once
func Initialize() error {
once.Do(func() {
// 初始化操作
if err := expensiveInit(); err != nil {
initError = err
// 注意：这里 Once 仍然认为已经执行过了
}
})
return initError
}
2. 不可重置性
sync.Once 执行后无法重置，如果需要重新初始化，需要创建新的 Once 实例。
3. 死锁风险
如果 f() 中调用了同一个 Once 实例的 Do 方法，会导致死锁：
var once sync.Once
func risky() {
once.Do(func() {
fmt.Println("First call")
once.Do(func() { // 死锁！等待自己释放锁
fmt.Println("This will never print")
})
})
}
总结
sync.Once 的设计体现了 Go 并发哲学的精髓：
- 简单性：接口极其简单，只有一个方法
- 高效性：双重检查模式最大化性能
- 正确性：基于 atomic 和 mutex 的强保证
- 实用性：解决真实的并发编程痛点
下次当你需要确保某个操作只执行一次时，记得使用 sync.Once - 这是 Go 并发工具箱中的一颗明珠。
思考题： 在你的项目中，哪些场景适合使用 sync.Once？有没有遇到过因为错误使用而导致的 bug？欢迎在评论区分享你的实战经验！
如果觉得这篇文章对你有帮助，请点赞、收藏、关注三连支持！我们下期再见。
