Golang使用sync.Once实现单次初始化

P粉602998670

发布时间：2025-09-08 08:47:01

731人浏览过

来源于php中文网

原创

sync.Once确保初始化逻辑在并发环境下仅执行一次，通过Do方法实现高效、安全的单次调用，避免资源竞争与重复初始化，适用于配置加载、连接池等场景，相比sync.Mutex更轻量且语义明确，但需注意其不可重试、不可重置特性及初始化函数内错误处理的封装。

golang使用sync.once实现单次初始化

sync.Once

在 Golang 中提供了一种简洁且并发安全的方式，确保某段代码，通常是资源的初始化逻辑，在整个程序运行期间只会被执行一次。这对于构建高效、健壮的并发系统至关重要，比如加载配置、初始化数据库连接池或设置全局单例对象，它能有效避免重复初始化带来的性能损耗或不一致性问题。

解决方案

使用

sync.Once

实现单次初始化非常直观。你只需要创建一个

sync.Once

类型的变量，然后调用它的

Do

方法，并传入一个

func()

类型的函数作为参数。无论

Do

方法被调用多少次，传入的函数都只会被执行一次。这个执行过程是并发安全的，即使有多个 Goroutine 同时尝试调用

Do

方法，也只有一个 Goroutine 会成功执行初始化函数，其他 Goroutine 会阻塞直到初始化完成。

这里是一个简单的例子：

package main

import (
    "fmt"
    "sync"
    "time"
)

// 定义一个 sync.Once 变量，通常作为全局变量或结构体成员
var (
    once       sync.Once
    // 假设这是我们需要单次初始化的资源
    globalConfig string
)

// initializeConfig 是我们的初始化函数
func initializeConfig() {
    fmt.Println("正在执行配置初始化逻辑...")
    time.Sleep(time.Millisecond * 200) // 模拟一个耗时的初始化过程
    globalConfig = "这是我加载的全局配置内容！"
    fmt.Println("配置初始化完成。")
}

// GetGlobalConfig 提供一个获取配置的方法，它会确保配置只被初始化一次
func GetGlobalConfig() string {
    // once.Do 会确保 initializeConfig 只被调用一次
    once.Do(initializeConfig)
    return globalConfig
}

func main() {
    var wg sync.WaitGroup
    fmt.Println("多个 Goroutine 尝试获取配置...")

    // 启动多个 Goroutine 并发获取配置
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d 尝试获取配置...\n", id)
            config := GetGlobalConfig()
            fmt.Printf("Goroutine %d 获取到配置: %s\n", id, config)
        }(i)
    }
    wg.Wait()

    fmt.Println("\n所有 Goroutine 都已完成。")
    // 再次获取，验证不会重复初始化
    fmt.Println("再次获取配置，验证不会重复初始化:", GetGlobalConfig())
}

运行这段代码，你会看到 "正在执行配置初始化逻辑..." 和 "配置初始化完成。" 只会出现一次，即使有多个 Goroutine 同时请求。这正是

sync.Once

的魅力所在。

立即学习“go语言免费学习笔记（深入）”；

Golang中为何需要单次初始化模式？

在 Golang 这样的并发环境中，单次初始化模式的重要性不言而喻。想象一下，你有一个全局的数据库连接池，或者一个日志系统的实例，它们在程序启动时可能需要一些复杂的设置。如果没有一个可靠的单次初始化机制，你可能会面临以下几个问题：

首先是资源竞争和重复初始化。如果多个 Goroutine 同时尝试初始化同一个资源，轻则可能造成资源浪费（比如重复加载配置文件），重则可能导致数据不一致、连接泄露甚至程序崩溃。比如，如果每个 Goroutine 都去创建自己的数据库连接，那很快就会耗尽连接数，或者连接池的状态会变得混乱。

其次是性能开销。有些初始化操作是相当耗时的，比如从磁盘读取大文件、进行网络请求获取配置。如果这些操作被重复执行，无疑会拖慢整个程序的性能。

在我看来，

sync.Once

就是 Golang 提供的一个“并发利器”，它把这些复杂的问题抽象成了一个简单易用的

Do

方法。它不仅仅是关于性能优化，更多的是关于程序的正确性和健壮性。它避免了手动编写复杂的锁逻辑来处理“只执行一次”的需求，从而降低了出错的可能性。对于那些需要在应用生命周期中确保某个组件或数据结构只被创建一次的场景，

sync.Once

几乎是标准答案。它让开发者能更专注于业务逻辑，而不是在并发控制的细节上反复纠结。

sync.Once与传统互斥锁（sync.Mutex）实现单例模式有何不同？

很多人在实现单例模式时，首先想到的可能是

sync.Mutex

。用

sync.Mutex

来实现单例确实可行，但

sync.Once

在设计上更专注于“只执行一次”这个特定场景，并为此做了优化，使其在性能和简洁性上都更胜一筹。

让我们先看看一个基于

sync.Mutex

的单例实现大致会是什么样子：

package main

import (
    "fmt"
    "sync"
    "time"
)

type Singleton struct {
    Name string
}

var (
    singletonInstance *Singleton
    singletonMutex    sync.Mutex
)

// GetSingletonMutex 通过 Mutex 实现单例
func GetSingletonMutex() *Singleton {
    singletonMutex.Lock() // 每次访问都需要加锁
    defer singletonMutex.Unlock() // 每次访问都需要解锁

    if singletonInstance == nil {
        fmt.Println("Mutex: 正在初始化单例...")
        time.Sleep(time.Millisecond * 50) // 模拟耗时
        singletonInstance = &Singleton{Name: "我是一个Mutex单例"}
        fmt.Println("Mutex: 单例初始化完成。")
    }
    return singletonInstance
}

对比

sync.Once

和

sync.Mutex

，它们的差异主要体现在：

Asp开源商城系统YothSHOP

YothSHOP是优斯科技鼎力打造的一款asp开源商城系统，支持access和Sql server切换，完善的会员订单管理，全站生成静态html文件，SEO优化效果极佳，后台XP模式和普通模式随意切换，极易操作，欢迎使用！ Asp开源商城系统YothSHOP功能介绍：1.使用静态页和程序页分离技术，网站可自由开启和关闭，实现全站生成静态页，可动静态切换，方便二次开发和后期维护。2.管理员管理：后台

下载

性能开销： 这是最核心的区别。
```
sync.Mutex
```
每次调用
```
GetSingletonMutex
```
时，无论单例是否已经初始化，都会执行加锁和解锁操作。尽管 Go 的
```
sync.Mutex
```
性能已经很高，但这些操作仍然会带来一定的开销。而
```
sync.Once
```
的
```
Do
```
方法，在初始化函数成功执行一次之后，后续的调用会变得非常轻量，几乎是零开销。它内部通过原子操作检查一个布尔标志位，一旦标志位表示已完成初始化，就直接返回，不再涉及锁的竞争和加解锁。这种“一次性加锁，后续免锁”的机制，使得
```
sync.Once
```
在高并发场景下效率更高。
简洁性与意图表达：
```
sync.Once
```
的 API 设计直接表达了“只执行一次”的意图，代码更清晰，更易于理解。开发者无需手动管理
```
nil
```
检查和锁的配对，这些细节都被
```
sync.Once
```
封装好了。使用
```
sync.Mutex
```
实现时，你需要自己编写
```
if instance == nil
```
的逻辑，并确保锁的正确使用，这增加了出错的可能性。
适用场景：
```
sync.Once
```
专为那些“生命周期中只执行一次”的任务而生。
```
sync.Mutex
```
则是一个通用的并发原语，用于保护任何临界区，可以多次加锁解锁，适用于需要频繁访问和修改共享资源的情况。所以，如果你的需求就是“只初始化一次”，那么
```
sync.Once
```
几乎总是更优的选择。

在我看来，

sync.Once

就像是 Go 语言为单例模式和延迟初始化量身定制的“特种工具”。它不是要取代

sync.Mutex

，而是提供了一个在特定场景下更高效、更优雅的替代方案。当你的代码里出现

if instance == nil { mutex.Lock(); defer mutex.Unlock(); if instance == nil { ... } }

这样的双重检查锁定模式时，也许就是时候考虑

sync.Once

了。

使用sync.Once时需要注意哪些潜在问题或最佳实践？

sync.Once

虽好用，但也有其特定的使用场景和需要注意的地方。理解这些能帮助我们更好地利用它，避免一些隐晦的问题。

一个非常重要的点是：

sync.Once.Do

传入的初始化函数
func()
是不能返回错误的。这意味着如果你的初始化逻辑可能会失败（比如连接数据库失败、读取配置文件出错），你不能直接通过

Do

方法的返回值来获取错误信息。在这种情况下，你需要将错误处理逻辑封装在

func()

内部，例如将错误记录到日志，或者将错误存储在一个全局变量中，供外部调用者后续检查。

var (
    onceErr     sync.Once
    resourceErr error
    myResource  *SomeResource
)

func initResourceWithErr() {
    // 模拟一个可能失败的初始化
    if err := loadConfig(); err != nil {
        resourceErr = fmt.Errorf("加载配置失败: %w", err)
        return // 初始化失败，但 Do 不会重试
    }
    myResource = &SomeResource{} // 假设成功初始化
    fmt.Println("资源初始化成功。")
}

func GetResource() (*SomeResource, error) {
    onceErr.Do(initResourceWithErr)
    return myResource, resourceErr // 返回初始化过程中可能产生的错误
}

这样的设计要求我们在每次获取资源时，不仅要拿到资源本身，还要检查是否有初始化错误。

其次，避免在初始化函数中发生死锁或长时间阻塞。 如果