Go语言实现单例模式的3种方法

uncle 行业资讯 2025年08月6日

0 收藏 0 点赞 483 浏览 2624 个字

摘要 :

文章目录 1. 线程安全的懒汉式单例 2. 双重检查锁定（DCL） 3. 原子操作法总结 Go语言如何实现单例模式？有哪几种方法？实现单例模式（Singleton Pattern）的核心使命……

文
章
目
录

1. 线程安全的懒汉式单例
2. 双重检查锁定（DCL）
3. 原子操作法
总结

Go语言如何实现单例模式？有哪几种方法？实现单例模式（Singleton Pattern）的核心使命是确保一个类仅有一个实例，并为程序提供一个全局访问该实例的入口。在实际场景中，当你需要严格控制某个对象的实例数量为一个时，单例模式就大显身手了，比如数据库连接池、日志管理器、配置管理器等组件的设计，它都能派上用场。

接下来，我们深入Go语言的世界，介绍3种实现单例模式的方式。

1. 线程安全的懒汉式单例

懒汉式单例的设计思路十分巧妙，它不会在程序启动时就迫不及待地创建实例，而是一直推迟到第一次被调用时才进行实例化操作。在多线程环境下，为了保证这种延迟创建的安全性，Go语言标准库中的 sync.Once 发挥了关键作用，它能确保实例仅被创建一次。

package main

import (
    \"fmt\"
    \"sync\"
)

var wg sync.WaitGroup

// Singleton 类型
type Singleton struct {
}

var instance *Singleton
var once sync.Once

// GetInstance 提供全局唯一的实例
func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

func main() {
    // 获取单例实例
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            s1 := GetInstance()
            fmt.Printf(\"index %d, memery address: %pn\", index, s1)
        }(i)
    }
    wg.Wait()
}

运行上述代码，你会得到类似这样的结果：

index 0, memery address: 0x56c480
index 5, memery address: 0x56c480
index 4, memery address: 0x56c480
index 2, memery address: 0x56c480
index 7, memery address: 0x56c480
index 9, memery address: 0x56c480
index 6, memery address: 0x56c480
index 8, memery address: 0x56c480
index 3, memery address: 0x56c480
index 1, memery address: 0x56c480

这表明，无论在多少个并发线程中获取实例，得到的都是同一个对象。

这里的 sync.Once 是Go语言并发编程中的一个重要同步原语，它保证了传入的函数只会被执行一次。而 once.Do 方法则是具体执行这个确保唯一性操作的关键，非常适合用于懒加载单例实例的场景。

2. 双重检查锁定（DCL）

双重检查锁定（Double-Checked Locking，简称DCL）是一种优化手段，旨在减少加锁带来的性能开销。它的实现方式是通过两次检查实例是否为空，从而提高获取单例的效率。

package main

import (
    \"fmt\"
    \"sync\"
)

var wg sync.WaitGroup

// Singleton 类型
type Singleton struct {
}

var instance *Singleton
var lock sync.Mutex

func GetInstance() *Singleton {
    if instance == nil {
        lock.Lock()
        defer lock.Unlock()
        if instance == nil {
            instance = &Singleton{}
        }
    }
    return instance
}

func main() {
    // 获取单例实例
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            s1 := GetInstance()
            fmt.Printf(\"index %d, memery address: %pn\", index, s1)
        }(i)
    }
    wg.Wait()
}

在这个实现中，首先会进行一次快速检查，判断实例是否已经存在。如果实例为空，才会进入加锁流程。加锁后，会再次检查实例是否为空，只有在此时实例仍然为空的情况下，才会创建实例。这种方式避免了每次获取实例时都进行加锁操作，大大提升了性能。

3. 原子操作法

Go语言的 sync/atomic 包提供了强大的原子操作功能，利用这一特性，我们也可以实现线程安全的单例模式。

package main

import (
    \"fmt\"
    \"sync\"
    \"sync/atomic\"
    \"unsafe\"
)

var wg sync.WaitGroup

type Singleton struct {
}

var instance unsafe.Pointer

func GetInstance() *Singleton {
    // 使用原子操作获取实例
    if atomic.LoadPointer(&instance) == nil {
        newInstance := &Singleton{}
        atomic.StorePointer(&instance, unsafe.Pointer(newInstance))
    }
    return (*Singleton)(atomic.LoadPointer(&instance))
}

func main() {
    // 获取单例实例
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            s1 := GetInstance()
            fmt.Printf(\"index %d, memery address: %pn\", index, s1)
        }(i)
    }
    wg.Wait()
}

在这段代码中，unsafe.Pointer 绕过了Go语言的类型系统，让我们可以直接操作内存地址。而 atomic.LoadPointer 和 atomic.StorePointer 这两个原子操作函数，则确保了对指针的加载和存储操作是线程安全的，从而保证了单例实例赋值的安全性。