创建型模式

package main​import (    "fmt"    "time")​// Log 结构体表示日志对象type Log struct {    logLevel string    logFile  string}​// 创建一个唯一的日志实例var instance = new(Log)​// GetInstance 获取日志实例的全局函数func GetInstance() *Log {    return instance}​// LogInfo 记录普通信息日志func (l *Log) LogInfo(message string) {    fmt.Printf("%s [INFO]: %s\n", time.Now().Format(time.RFC3339), message)}​// LogError 记录错误日志func (l *Log) LogError(message string) {    fmt.Printf("%s [ERROR]: %s\n", time.Now().Format(time.RFC3339), message)}​func main() {    // 获取单例实例    log1 := GetInstance()        // 记录日志    log1.LogInfo("这是log1的普通信息日志")    log1.LogError("这是log1的错误信息日志")        // 再次获取实例    log2 := GetInstance()    log2.LogInfo("这是log2的普通信息日志")        // 检查两次获取的实例是否是同一个    fmt.Println("log1和log2是否是相同实例", log1 == log2)}

2025-02-06T11:16:30+08:00 [INFO]: 这是log1的普通信息日志2025-02-06T11:16:30+08:00 [ERROR]: 这是log1的错误信息日志2025-02-06T11:16:30+08:00 [INFO]: 这是log2的普通信息日志log1和log2是否是相同实例 true

package main​import "fmt"​// CacheManager 是缓存管理器的结构体type CacheManager struct {	cache map[string]string}​// 存储缓存管理器的单例实例var instance *CacheManager​// GetInstance 获取缓存管理器的单例实例func GetInstance() *CacheManager {	// 只有在第一次访问时才创建实例	if instance == nil {		instance = &CacheManager{			cache: make(map[string]string),		}		fmt.Println("缓存管理器已初始化") // 仅在第一次调用时打印	}	return instance}​// SetCache 设置缓存func (cm *CacheManager) SetCache(key, value string) {	cm.cache[key] = value}​// GetCache 获取缓存值func (cm *CacheManager) GetCache(key string) string {	return cm.cache[key]}​func main() {	// 模拟使用缓存管理器	cache1 := GetInstance()	cache1.SetCache("user_1", "Alice")	cache1.SetCache("user_2", "Bob")​	// 再次获取缓存管理器实例	cache2 := GetInstance()	fmt.Println("cache1 == cache2:", cache1 == cache2) // 打印为 true，验证单例​	// 获取缓存值	fmt.Println("user_1:", cache2.GetCache("user_1"))	fmt.Println("user_2:", cache2.GetCache("user_2"))}

缓存管理器已初始化cache1 == cache2: trueuser_1: Aliceuser_2: Bob

func main() {	var wg sync.WaitGroup	wg.Add(5)​	// 模拟并发访问	for i := 0; i < 5; i++ {		go func(i int) {			defer wg.Done()			// 获取缓存管理器实例			cacheInstance := GetInstance()			cacheInstance.SetCache(fmt.Sprintf("user_%d", i+1), fmt.Sprintf("User_%d", i+1))			// 打印当前缓存			fmt.Printf("goroutine %d - %v\n", i+1, cacheInstance.cache)		}(i)	}​	// 等待所有 goroutine 执行完	wg.Wait()}

缓存管理器已初始化goroutine 1 - map[user_1:User_1]goroutine 4 - map[user_1:User_1 user_2:User_2 user_4:User_4 user_5:User_5]goroutine 2 - map[user_1:User_1 user_2:User_2 user_4:User_4 user_5:User_5]goroutine 5 - map[user_1:User_1 user_5:User_5]goroutine 3 - map[user_1:User_1 user_2:User_2 user_3:User_3 user_4:User_4 user_5:User_5]

package main​import (	"fmt"	"sync")​// CacheManager 是缓存管理器的结构体type CacheManager struct {	cache map[string]string}​// 存储缓存管理器的单例实例var instance *CacheManagervar mu sync.Mutex // 用于加锁，确保线程安全​// GetInstance 获取缓存管理器的单例实例func GetInstance() *CacheManager {	// 加锁确保线程安全	mu.Lock()	defer mu.Unlock()​	// 只有在第一次访问时才创建实例	if instance == nil {		instance = &CacheManager{			cache: make(map[string]string),		}		fmt.Println("缓存管理器已初始化") // 仅在第一次调用时打印	}	return instance}​// SetCache 设置缓存func (cm *CacheManager) SetCache(key, value string) {	cm.cache[key] = value}​// GetCache 获取缓存值func (cm *CacheManager) GetCache(key string) string {	return cm.cache[key]}​func main() {	// 模拟使用缓存管理器	cache1 := GetInstance()	cache1.SetCache("user_1", "Alice")	cache1.SetCache("user_2", "Bob")​	// 再次获取缓存管理器实例	cache2 := GetInstance()	fmt.Println("cache1 == cache2:", cache1 == cache2) // 打印为 true，验证单例​	// 获取缓存值	fmt.Println("user_1:", cache2.GetCache("user_1"))	fmt.Println("user_2:", cache2.GetCache("user_2"))}

缓存管理器已初始化cache1 == cache2: trueuser_1: Aliceuser_2: Bob

package main​import (	"fmt"	"sync"	"sync/atomic")​// CacheManager 是缓存管理器的结构体type CacheManager struct {	cache map[string]string}​// 存储缓存管理器的单例实例var instance *CacheManagervar initialized uint32 // 用于标记是否初始化（0：未初始化，1：已初始化）var mu sync.Mutex      // 互斥锁，确保初始化的安全性​// GetInstance 获取缓存管理器的单例实例（使用 atomic 进行优化）func GetInstance() *CacheManager {	// 第一层检查（无锁）: 如果实例已初始化，直接返回，避免加锁	if atomic.LoadUint32(&initialized) == 1 {		return instance	}​	// 加锁确保线程安全	mu.Lock()	defer mu.Unlock()​	// 第二层检查（有锁）: 再次检查，避免多个线程初始化	if instance == nil {		instance = &CacheManager{			cache: make(map[string]string),		}		fmt.Println("缓存管理器已初始化") // 仅在第一次调用时打印​		// 标记为已初始化		atomic.StoreUint32(&initialized, 1)	}​	return instance}​// SetCache 设置缓存func (cm *CacheManager) SetCache(key, value string) {	cm.cache[key] = value}​// GetCache 获取缓存值func (cm *CacheManager) GetCache(key string) string {	return cm.cache[key]}​func main() {	// 模拟使用缓存管理器	cache1 := GetInstance()	cache1.SetCache("user_1", "Alice")	cache1.SetCache("user_2", "Bob")​	// 再次获取缓存管理器实例	cache2 := GetInstance()	fmt.Println("cache1 == cache2:", cache1 == cache2) // 打印为 true，验证单例​	// 获取缓存值	fmt.Println("user_1:", cache2.GetCache("user_1"))	fmt.Println("user_2:", cache2.GetCache("user_2"))}

缓存管理器已初始化cache1 == cache2: trueuser_1: Aliceuser_2: Bob

// Once is an object that will perform exactly one action.//// A Once must not be copied after first use.//// In the terminology of the Go memory model,// the return from f “synchronizes before”// the return from any call of once.Do(f).type Once struct {	// done indicates whether the action has been performed.	// It is first in the struct because it is used in the hot path.	// The hot path is inlined at every call site.	// Placing done first allows more compact instructions on some architectures (amd64/386),	// and fewer instructions (to calculate offset) on other architectures.	done atomic.Uint32	m    Mutex}​// Do calls the function f if and only if Do is being called for the// first time for this instance of Once. In other words, given////	var once Once//// if once.Do(f) is called multiple times, only the first call will invoke f,// even if f has a different value in each invocation. A new instance of// Once is required for each function to execute.//// Do is intended for initialization that must be run exactly once. Since f// is niladic, it may be necessary to use a function literal to capture the// arguments to a function to be invoked by Do:////	config.once.Do(func() { config.init(filename) })//// Because no call to Do returns until the one call to f returns, if f causes// Do to be called, it will deadlock.//// If f panics, Do considers it to have returned; future calls of Do return// without calling f.func (o *Once) Do(f func()) {	// Note: Here is an incorrect implementation of Do:	//	//	if o.done.CompareAndSwap(0, 1) {	//		f()	//	}	//	// Do guarantees that when it returns, f has finished.	// This implementation would not implement that guarantee:	// given two simultaneous calls, the winner of the cas would	// call f, and the second would return immediately, without	// waiting for the first's call to f to complete.	// This is why the slow path falls back to a mutex, and why	// the o.done.Store must be delayed until after f returns.​	if o.done.Load() == 0 {		// Outlined slow-path to allow inlining of the fast-path.		o.doSlow(f)	}}​func (o *Once) doSlow(f func()) {	o.m.Lock()	defer o.m.Unlock()	if o.done.Load() == 0 {		defer o.done.Store(1)		f()	}}

type Once struct {    done atomic.Uint32  // 用于标记 Do 是否已执行    m    Mutex          // 用于加锁，确保线程安全}

// done first in the struct because it is used in the hot path.// The hot path is inlined at every call site.// Placing done first allows more compact instructions on some architectures (amd64/386),// and fewer instructions (to calculate offset) on other architectures.done atomic.Uint32

func (o *Once) Do(f func()) {    if o.done.Load() == 0 { // 如果没有执行过        o.doSlow(f)         // 执行慢路径    }}

func (o *Once) doSlow(f func()) {    o.m.Lock()      // 获取锁，确保只有一个 goroutine 可以执行 f()    defer o.m.Unlock()​    if o.done.Load() == 0 {        f()          // 执行目标函数        o.done.Store(1)  // 设置 `done` 为 1，表示已经执行过    }}

package main​import (	"fmt"	"sync")​// CacheManager 是缓存管理器的结构体type CacheManager struct {	cache map[string]string}​// 存储缓存管理器的单例实例var instance *CacheManagervar once sync.Once // `sync.Once` 确保只执行一次​// GetInstance 获取缓存管理器的单例实例func GetInstance() *CacheManager {	once.Do(func() {		instance = &CacheManager{			cache: make(map[string]string),		}		fmt.Println("缓存管理器已初始化") // 仅在第一次调用时打印	})	return instance}​// SetCache 设置缓存func (cm *CacheManager) SetCache(key, value string) {	cm.cache[key] = value}​// GetCache 获取缓存值func (cm *CacheManager) GetCache(key string) string {	return cm.cache[key]}​func main() {	// 模拟使用缓存管理器	cache1 := GetInstance()	cache1.SetCache("user_1", "Alice")	cache1.SetCache("user_2", "Bob")​	// 再次获取缓存管理器实例	cache2 := GetInstance()	fmt.Println("cache1 == cache2:", cache1 == cache2) // 打印为 true，验证单例​	// 获取缓存值	fmt.Println("user_1:", cache2.GetCache("user_1"))	fmt.Println("user_2:", cache2.GetCache("user_2"))}

缓存管理器已初始化cache1 == cache2: trueuser_1: Aliceuser_2: Bob

package main​import "fmt"​// Logger 是日志接口type Logger interface {	Log(message string)}​// FileLogger 具体的文件日志type FileLogger struct{}​func (f *FileLogger) Log(message string) {	fmt.Println("[FileLogger]:", message)}​// ConsoleLogger 具体的控制台日志type ConsoleLogger struct{}​func (c *ConsoleLogger) Log(message string) {	fmt.Println("[ConsoleLogger]:", message)}​// LoggerFactory 是简单工厂方法，根据 logType 创建不同的 Logger 实例func LoggerFactory(logType string) Logger {	if logType == "file" {		return &FileLogger{}	} else if logType == "console" {		return &ConsoleLogger{}	}	return nil}​// 客户端代码func main() {	// 创建文件日志	fileLogger := LoggerFactory("file")	fileLogger.Log("This is a file log")​	// 创建控制台日志	consoleLogger := LoggerFactory("console")	consoleLogger.Log("This is a console log")}

[FileLogger]: This is a file log[ConsoleLogger]: This is a console log

package main​import "fmt"​// Database 定义数据库接口type Database interface {	Connect() string}​// MySQL 实现 Database 接口type MySQL struct{}​func (m *MySQL) Connect() string {	return "Connected to MySQL"}​// PostgreSQL 实现 Database 接口type PostgreSQL struct{}​func (p *PostgreSQL) Connect() string {	return "Connected to PostgreSQL"}​// DatabaseFactory 是工厂方法接口type DatabaseFactory interface {	CreateDatabase() Database}​// MySQLFactory 负责创建 MySQLtype MySQLFactory struct{}​func (f *MySQLFactory) CreateDatabase() Database {	return &MySQL{}}​// PostgreSQLFactory 负责创建 PostgreSQLtype PostgreSQLFactory struct{}​func (f *PostgreSQLFactory) CreateDatabase() Database {	return &PostgreSQL{}}​func main() {	var factory DatabaseFactory​	// 使用 MySQL 工厂创建 MySQL 实例	factory = &MySQLFactory{}	mysql := factory.CreateDatabase()	fmt.Println(mysql.Connect())​	// 使用 PostgreSQL 工厂创建 PostgreSQL 实例	factory = &PostgreSQLFactory{}	postgres := factory.CreateDatabase()	fmt.Println(postgres.Connect())}

Connected to MySQLConnected to PostgreSQL

package main​import "fmt"​// Button 按钮接口type Button interface {	Render()}​// Checkbox 复选框接口type Checkbox interface {	Render()}​// WindowsButton 具体按钮type WindowsButton struct{}​func (w *WindowsButton) Render() {	fmt.Println("Rendering Windows Button")}​// MacButton 具体按钮type MacButton struct{}​func (m *MacButton) Render() {	fmt.Println("Rendering Mac Button")}​// WindowsCheckbox 具体复选框type WindowsCheckbox struct{}​func (w *WindowsCheckbox) Render() {	fmt.Println("Rendering Windows Checkbox")}​// MacCheckbox 具体复选框type MacCheckbox struct{}​func (m *MacCheckbox) Render() {	fmt.Println("Rendering Mac Checkbox")}​// GUIFactory 抽象工厂接口type GUIFactory interface {	CreateButton() Button	CreateCheckbox() Checkbox}​// WindowsFactory 负责创建 Windows GUItype WindowsFactory struct{}​func (w *WindowsFactory) CreateButton() Button {	return &WindowsButton{}}​func (w *WindowsFactory) CreateCheckbox() Checkbox {	return &WindowsCheckbox{}}​// MacFactory 负责创建 Mac GUItype MacFactory struct{}​func (m *MacFactory) CreateButton() Button {	return &MacButton{}}​func (m *MacFactory) CreateCheckbox() Checkbox {	return &MacCheckbox{}}​func main() {	// 使用 Windows 工厂创建 Windows GUI	var factory GUIFactory = &WindowsFactory{}	button := factory.CreateButton()	checkbox := factory.CreateCheckbox()	button.Render()	checkbox.Render()​	// 使用 Mac 工厂创建 Mac GUI	factory = &MacFactory{}	button = factory.CreateButton()	checkbox = factory.CreateCheckbox()	button.Render()	checkbox.Render()}

Rendering Windows ButtonRendering Windows CheckboxRendering Mac ButtonRendering Mac Checkbox