Go单例模式实现sync.Once与双重检查

package singleton

import (
	"sync"
)

// Config 全局配置单例
type Config struct {
	AppName string
	Version string
	Timeout int
}

var (
	instance *Config
	once     sync.Once
)

// GetInstance 获取单例实例
// sync.Once保证初始化只执行一次，并发安全
func GetInstance() *Config {
	// Do方法内部先检查done标志
	// done为true直接返回，不加锁
	once.Do(func() {
		// 这里执行初始化逻辑
		// 只会有一个goroutine执行到这里
		instance = &Config{
			AppName: "my-app",
			Version: "v1.0.0",
			Timeout: 30,
		}
	})
	return instance
}

package sync

import (
	"sync/atomic"
)

// Once 标准库sync.Once的简化实现
type Once struct {
	done atomic.Bool
	m    Mutex
}

// Do 核心方法
func (o *Once) Do(f func()) {
	// 快速路径: 原子检查done标志
	// 已完成则直接返回，无需加锁
	if o.done.Load() {
		return
	}
	// 慢速路径: 加锁后双重检查
	o.doSlow(f)
}

// doSlow 加锁路径，处理真正初始化
func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()

	// 双重检查，防止多个goroutine同时通过快速路径
	if !o.done.Load() {
		// 延迟设置done，确保f执行完成后才标记完成
		defer o.done.Store(true)
		f()
	}
}

package singleton

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

// Database 数据库连接单例
type Database struct {
	url string
}

var (
	dbInstance *Database
	dbMu       sync.Mutex
)

// GetDB 双重检查锁实现单例
// 比直接加锁快，读多写少场景优势明显
func GetDB() *Database {
	// 第一次检查: 不加锁
	// 用atomic.LoadPointer保证读到完整的指针值
	ptr := atomic.LoadPointer(
		(*unsafe.Pointer)(unsafe.Pointer(&dbInstance)),
	)
	if ptr != nil {
		// 已初始化，直接返回
		return (*Database)(ptr)
	}

	// 加锁准备初始化
	dbMu.Lock()
	defer dbMu.Unlock()

	// 第二次检查: 防止多个goroutine同时通过第一次检查
	if dbInstance == nil {
		// 真正的初始化逻辑
		dbInstance = &Database{
			url: "mysql://root:pass@127.0.0.1:3306/db",
		}
	}
	return dbInstance
}

package singleton

import (
	"log"
	"sync"
)

var (
	cacheInstance *Cache
	cacheOnce     sync.Once
)

// Cache 缓存单例
type Cache struct {
	data map[string]string
}

// GetCache 错误示范: 在Do内部recover
func GetCache() *Cache {
	cacheOnce.Do(func() {
		// 在Do内部recover，问题在于
		// panic被recover后done仍会被设为true
		defer func() {
			if r := recover(); r != nil {
				log.Printf("初始化panic: %v", r)
			}
		}()

		// 这里模拟可能panic的初始化
		cacheInstance = &Cache{
			data: map[string]string{
				"key": "value",
			},
		}
		// 假设这行panic了
		// done会被设为true，但cacheInstance可能不完整
	})
	return cacheInstance
}

package singleton

import (
	"sync"
	"sync/atomic"
)

// ResettableOnce 可重置的Once
// 初始化失败后可以重置，允许重新初始化
type ResettableOnce struct {
	done atomic.Bool
	m    sync.Mutex
}

// Do 执行f，done为false时才执行
// f返回error，不设置done，允许重试
func (o *ResettableOnce) Do(f func() error) error {
	// 快速路径: 已完成直接返回
	if o.done.Load() {
		return nil
	}

	o.m.Lock()
	defer o.m.Unlock()

	// 双重检查
	if !o.done.Load() {
		// 执行初始化
		if err := f(); err != nil {
			// 失败，不设置done，允许重试
			return err
		}
		// 成功才设置done
		o.done.Store(true)
	}
	return nil
}

// Reset 重置状态，允许重新初始化
func (o *ResettableOnce) Reset() {
	o.m.Lock()
	defer o.m.Unlock()
	o.done.Store(false)
}

// 可重置单例的使用示例
var (
	configInstance *Config
	configOnce     ResettableOnce
)

// GetConfigWithRetry 支持重试的配置获取
func GetConfigWithRetry() (*Config, error) {
	err := configOnce.Do(func() error {
		// 初始化逻辑，返回error而非panic
		cfg, initErr := initConfigFromRemote()
		if initErr != nil {
			return initErr
		}
		configInstance = cfg
		return nil
	})
	if err != nil {
		return nil, err
	}
	return configInstance, nil
}

// initConfigFromRemote 模拟从远程拉配置
func initConfigFromRemote() (*Config, error) {
	return &Config{
		AppName: "my-app",
		Version: "v1.0.0",
		Timeout: 30,
	}, nil
}