首页 > 脚本专栏 > Golang > Go语言单例模式

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

2025-07-29 10:55:33 作者：喜欢代码的新之助

单例模式是一种创建型设计模式,Go中常见实现包括使用sync.Once、双重检查锁定和原子操作法,每种方法都有其独特的优点和适用场景,下面就来具体介绍一下

单例模式的基本定义

单例模式（Singleton Pattern）是一种创建型设计模式，其核心思想在于确保一个类仅有一个实例，并提供一个全局访问点。该模式广泛应用于需要严格控制对象数量的场景，诸如数据库连接池、日志管理器、配置管理器等。

Go语言中的单例模式实现

在Go语言中，实现单例模式有多种方法，以下介绍几种常见且线程安全的实现方式：

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

懒汉式实现会延迟实例的创建，直到首次调用时才会实例化对象。为了保证并发安全，我们使用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, memory address: %p\n", index, s1)
		}(i)
	}
	wg.Wait()
}

解析：

sync.Once：确保传入的函数只执行一次，适用于懒加载单例实例。
once.Do：确保实例的创建操作只执行一次，且线程安全。

2. 双重检查锁定（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, memory address: %p\n", index, s1)
		}(i)
	}
	wg.Wait()
}

解析：

双重检查：第一次无锁检查避免不必要的加锁开销，第二次加锁检查确保实例安全创建。
锁优化：仅在实例尚未创建时加锁，提高了性能。

3. 原子操作法

利用sync/atomic包提供的原子操作，确保单例的线程安全。

package main
 
import (
	"fmt"
	"sync"
	"sync/atomic"
	"unsafe"
)
 
var wg sync.WaitGroup
 
// Singleton 结构体定义
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, memory address: %p\n", index, s1)
		}(i)
	}
	wg.Wait()
}

解析：

unsafe.Pointer：用于直接处理内存地址，绕过类型系统。
atomic.LoadPointer和atomic.StorePointer：原子加载和存储指针，确保线程安全。

总结

在Go语言中，实现单例模式有多种方法，包括使用sync.Once、双重检查锁定和原子操作法。每种方法都有其独特的优点和适用场景。选择哪种方法取决于具体需求，如性能要求、代码简洁性等。在实际应用中，可以根据具体场景权衡利弊，选择最合适的实现方式。

到此这篇关于Go语言实现单例模式的多种方法的文章就介绍到这了,更多相关Go语言单例模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！