在日常开发中，我们经常会遇到需要确保某些操作只执行一次的场景，比如初始化配置、建立数据库连接、创建单例对象等。

在Go语言的并发世界里，如何安全高效地实现这些功能？这里就来深入探讨一下Go标准库中的利器——sync.Once。

sync.Once是Go标准库sync包中的一个结构体，它提供了一种简洁而高效的机制，能够确保某个函数在整个程序运行期间只执行一次，无论有多少个goroutine同时调用它。

你可以把它想象成一个"一次性开关"：第一次触发时，开关打开，代码被执行；后续触发时，开关已经处于打开状态，代码不再执行。

核心用法

sync.Once极其简单，只有一个方法：

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

它接受一个无参数、无返回值的函数，并保证这个函数只执行一次。

下面是一个简单示例：

package main

import (
    "fmt"
    "sync"
)

var once sync.Once

func initialize() {
    fmt.Println("Initializing...")
}

func main() {
    // 多个goroutine并发调用
    for i := 0; i < 5; i++ {
        go once.Do(initialize)
    }
    // 等待所有goroutine执行
    fmt.Scanln()
}

运行这段代码，你会发现无论执行多少次，都只会输出一次"Initializing..."。

工作原理

sync.Once的内部实现巧妙结合了原子操作和互斥锁，既保证了线程安全，又兼顾了性能。

其结构体定义如下：

// sync/once.go
type Once struct {
    _ noCopy

    done atomic.Uint32 // 标记是否已执行
    m    Mutex // 互斥锁，用于并发控制
}

Do方法的执行流程分为两个路径：

  1. 快速路径：通过atomic.LoadUint32原子性地检查done标志，如果已执行（值为1），立即返回
  2. 慢速路径：如果未执行（值为0），加互斥锁进入临界区，进行双重检查，确认是否执行函数

这种"双重检查锁定"机制避免了每次调用都加锁的性能开销，大多数调用只需一次原子读操作就能快速返回。

应用场景

其时sync.Once的功能比较单一，所有它的应用场景也大差不差。

1. 单例模式实现

这是sync.Once最典型的应用场景，确保全局唯一实例只创建一次：

var (
    instance *Singleton
    once     sync.Once
)

type Singleton struct {
    value int
}

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{value: 42}
        fmt.Println("Singleton instance created")
    })
    return instance
}

2. 延迟初始化资源

对于数据库连接、文件句柄等昂贵资源，使用sync.Once可以实现按需初始化，避免程序启动时不必要的资源占用：

var (
    db   *sql.DB
    once sync.Once
)

func GetDB() (*sql.DB, error) {
    once.Do(func() {
        var err error
        db, err = sql.Open("mysql", "user:pass@/dbname")
        if err != nil {
            panic(err) // 实际项目中应更优雅地处理错误
        }
    })
    return db, nil
}

3. 加载配置信息

确保配置信息只加载一次，避免重复解析配置文件：

var (
    appConfig *Config
    once      sync.Once
)

type Config struct {
    APIKey string
    Debug  bool
}

func LoadConfig() *Config {
    once.Do(func() {
        // 从文件或环境变量加载配置
        appConfig = &Config{
            APIKey: os.Getenv("API_KEY"),
            Debug:  os.Getenv("DEBUG") == "true",
        }
    })
    return appConfig
}

最佳实践

  1. 不可重置：一旦Do方法执行了函数，sync.Once的状态就不可逆转，无法重置重用。

  2. 错误处理：如果Do内部的函数执行时发生错误或panic，sync.Once会标记为已执行，后续调用不会再执行该函数。需要自行处理函数内的错误。

  3. 避免死锁：不要在Do方法传入的函数内部再次调用同一个sync.Once实例的Do方法，这会导致死锁。

  4. 参数传递：Do方法接受的函数必须是无参数、无返回值的。如果需要传递参数，可以通过闭包方式实现：

    configFile := "app.conf"
once.Do(func() {
    initConfig(configFile)
})

  5. 性能考量：首次调用有加锁开销，但后续调用只需一次原子读操作，性能接近直接访问全局变量。

同类对比

同步机制 特点 适用场景
sync.Once 确保代码只执行一次 一次性初始化任务
sync.Mutex 手动控制加锁，灵活性高 需要多次读写共享资源的场景
Channel 通过通信协调协程 需要复杂协作逻辑的场景
init()函数 包级别的静态初始化 模块初始化，缺乏运行时控制

写在最后

sync.Once是Go语言并发编程中一个简单而强大的工具，它通过简洁的API解决了并发环境下一次性初始化的常见问题。

无论是实现单例模式、延迟初始化昂贵资源，还是加载配置信息，sync.Once都能提供线程安全且高效的解决方案。

其内部巧妙结合的原子操作和互斥锁机制，既保证了正确性，又兼顾了性能优势，是Go语言"力求简洁"哲学的优秀体现。