Go语言中Once懒加载的艺术详析

package main
import (
	"fmt"
	"sync"
)
var once sync.Once
func initialize() {
	fmt.Println("Initializing...")
	// 执行初始化操作
}
func main() {
	// 多次调用，但只会执行一次
	for i := 0; i < 5; i++ {
		once.Do(initialize)
	}
	fmt.Println("Done")
}

package main
import (
	"fmt"
	"sync"
)
type Singleton struct {
	data string
}
var (
	instance *Singleton
	once     sync.Once
)
func GetInstance() *Singleton {
	once.Do(func() {
		instance = &Singleton{
			data: "Singleton Data",
		}
		fmt.Println("Singleton created")
	})
	return instance
}
func main() {
	// 多次获取实例，但只会创建一次
	for i := 0; i < 5; i++ {
		s := GetInstance()
		fmt.Printf("Instance %d: %p, Data: %s\n", i, s, s.data)
	}
}

package main
import (
	"fmt"
	"sync"
)
var (
	config map[string]string
	once   sync.Once
)
func loadConfig() {
	fmt.Println("Loading config...")
	config = map[string]string{
		"host": "localhost",
		"port": "8080",
	}
}
func GetConfig() map[string]string {
	once.Do(loadConfig)
	return config
}
func main() {
	var wg sync.WaitGroup
	// 多个协程同时获取配置
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			cfg := GetConfig()
			fmt.Printf("Goroutine %d: %v\n", id, cfg)
		}(i)
	}
	wg.Wait()
}

package main
import (
	"errors"
	"fmt"
	"sync"
)
var (
	result string
	err    error
	once   sync.Once
)
func initialize() {
	fmt.Println("Initializing...")
	// 模拟初始化失败
	err = errors.New("initialization failed")
	result = ""
}
func GetResult() (string, error) {
	once.Do(initialize)
	return result, err
}
func main() {
	// 多次调用，但只会执行一次
	for i := 0; i < 3; i++ {
		r, e := GetResult()
		fmt.Printf("Call %d: result=%s, err=%v\n", i, r, e)
	}
}

package main
import (
	"database/sql"
	"fmt"
	"sync"
	_ "github.com/go-sql-driver/mysql"
)
var (
	db   *sql.DB
	once sync.Once
)
func initDB() {
	var err error
	db, err = sql.Open("mysql", "user:password@/dbname")
	if err != nil {
		panic(err)
	}
	fmt.Println("Database initialized")
}
func GetDB() *sql.DB {
	once.Do(initDB)
	return db
}
func main() {
	// 多次获取数据库连接
	for i := 0; i < 3; i++ {
		database := GetDB()
		fmt.Printf("DB instance %d: %p\n", i, database)
	}
}

package main
import (
	"encoding/json"
	"fmt"
	"os"
	"sync"
)
type Config struct {
	Server string `json:"server"`
	Port   int    `json:"port"`
	Debug  bool   `json:"debug"`
}
var (
	config *Config
	once   sync.Once
)
func loadConfig() {
	fmt.Println("Loading configuration...")
	data, err := os.ReadFile("config.json")
	if err != nil {
		// 使用默认配置
		config = &Config{
			Server: "localhost",
			Port:   8080,
			Debug:  false,
		}
		return
	}
	config = &Config{}
	json.Unmarshal(data, config)
}
func GetConfig() *Config {
	once.Do(loadConfig)
	return config
}
func main() {
	// 多个协程同时获取配置
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			cfg := GetConfig()
			fmt.Printf("Goroutine %d: Server=%s, Port=%d\n", id, cfg.Server, cfg.Port)
		}(i)
	}
	wg.Wait()
}

package main
import (
	"fmt"
	"log"
	"os"
	"sync"
)
var (
	logger *log.Logger
	once   sync.Once
)
func initLogger() {
	fmt.Println("Initializing logger...")
	file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Fatal(err)
	}
	logger = log.New(file, "APP: ", log.Ldate|log.Ltime|log.Lshortfile)
}
func GetLogger() *log.Logger {
	once.Do(initLogger)
	return logger
}
func main() {
	// 多次获取日志实例
	for i := 0; i < 3; i++ {
		log := GetLogger()
		log.Printf("Log entry %d", i)
		fmt.Printf("Logger instance %d: %p\n", i, log)
	}
}