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

目录

• 单例模式的基本定义
• Go语言单例模式的实现
• 1. 线程安全的懒汉式单例
• 解析：
• 2. 双重检查锁定（DCL）
• 解析：
• 3. 原子操作法
• 解析：
• 总结

单例模式的基本定义

单例模式（Singleton Pattern）是一种设计模式，旨在保证一个类只有一个实例，并且提供全局访问点。单例模式通常用于需要限制某个对象的实例数量为一个的场景，比如数据库连接池、日志管理器、配置管理器等。

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, memery address: %p\n", 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）

双重检查锁定是一种优化方式，它通过在两次检查实例时，减少了加锁的开销，提高了性能。

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 = &Single编程客栈ton{}
		}
	}
	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: %p\n", index, s1)
		}(i)

	}
	wg.Wait()
}

解析：

• 双重检查：第一次检查实例是否为 nil，如果是，则加锁。然后再次检查实例是否为 nil，如果是则创建实例。
• 锁的优化：只有在实例尚未创建时才会加锁，避免了每次获取实例时都需要加锁的性能损耗。

3. 原子操作法

Go 语言的 sync/atomic 包提供了原子操作，我们可以利用它来确保单例的线程安全。

package main

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

va编程r wg sync.WaitGroup

type Singleton struct {
}

var instance unsafe.Pointer

func GetInstance() *Singleton {
	// 使用原子操作获取实例
	if atomic.LoadPointer(&instance) == nil {
		newInstwww.devze.coma编程nce := &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 python:= GetInstance()
			fmt.Printf("index %d, memery address: %p\n", index, s1)
		}(i)

	}
	wg.Wait()
}

解析：

• unsafe.Pointer：在Go中，unsafe.Pointer 可以用来绕过类型系统，直接处理内存地址。通过原子操作确保实例赋值的安全性。
• atomic.LoadPointer 和 atomic.StorePointer：原子加载和存储指针，确保操作的线程安全性。

总结

在Go语言中实现单例模式有多种方式，最常见的是使用 sync.Once、双重检查锁定（DCL）和原子操作法。每种方法有其优缺点，选择合适的方式可以帮助你在保证线程安全的前提下优化性能。

到此这篇关于Go语言优雅实现单例模式的多种方式的文章就介绍到这了,更多相关Go实现单例模式内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！