var config map[string]string // 全局配置

func handleRequest() {
    // 在读取 config 的过程中，如果另一个 Goroutine 更新了 config
    // 可能会导致部分旧配置和新配置混用，或者程序崩溃
    useConfig := config 
    // ... 处理请求，使用 useConfig
}

func updateConfig(newConfig map[string]string) {
    // 直接赋值，在并发情况下极其危险
    config = newConfig
}

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	config   map[string]string
	configMu sync.RWMutex // 专门用于保护 config 的读写锁
)

// LoadConfig 模拟从文件或数据库加载配置
func LoadConfig() map[string]string {
	return map[string]string{
		"host": "127.0.0.1",
		"port": "8080",
	}
}

// InitConfig 初始化配置
func InitConfig() {
	config = LoadConfig()
}

// GetConfig 获取配置（读操作）
func GetConfig(key string) (string, bool) {
	configMu.RLock()         // 获取读锁
	defer configMu.RUnlock() // 函数返回前释放读锁
    // 多个 Goroutine 可以同时执行到这里
	value, ok := config[key]
	return value, ok
}

// ReloadConfig 重载配置（写操作）
func ReloadConfig() {
	newConfig := LoadConfig()
	configMu.Lock()         // 获取写锁
	defer configMu.Unlock() // 函数返回前释放写锁
    // 获取写锁后，会阻塞直到所有现有的读锁释放，并且阻止新的读锁获取
	config = newConfig
	fmt.Println("Config reloaded at", time.Now())
}

// 模拟大量的读取操作
func main() {
	InitConfig()

	// 模拟一个后台定时更新配置的 Goroutine
	go func() {
		for range time.Tick(5 * time.Second) { // 每5秒更新一次（写操作很少）
			ReloadConfig()
		}
	}()

	// 模拟大量的客户端请求，频繁读取配置
	for i := 0; i < 100; i++ {
		go func(id int) {
			for {
				host, _ := GetConfig("host") // 高频率的读操作
				port, _ := GetConfig("port")
				// fmt.Printf("Goroutine %d: Connecting to %s:%s\n", id, host, port)
				_ = host + port // 假装使用一下
				time.Sleep(100 * time.Millisecond)
			}
		}(i)
	}

	// 让主 Goroutine 不要退出
	time.Sleep(1 * time.Minute)
}

package main

import (
	"sync"
	"time"
)

type Cache struct {
	mu    sync.RWMutex
	items map[string]Item
}

type Item struct {
	Value      interface{}
	Expiration int64 // 过期时间（时间戳）
}

func (c *Cache) Get(key string) (interface{}, bool) {
	c.mu.RLock() // 获取读锁，检查键是否存在
	defer c.mu.RUnlock()

	item, found := c.items[key]
	if !found {
		return nil, false
	}
    // 检查是否过期
	if time.Now().UnixNano() > item.Expiration {
		return nil, false
	}
	return item.Value, true
}

func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
    // 计算过期时间
	expiration := time.Now().Add(duration).UnixNano()

	c.mu.Lock() // 获取写锁以设置值
	defer c.mu.Unlock()
	c.items[key] = Item{
		Value:      value,
		Expiration: expiration,
	}
}

// 定期清理过期的键（写操作）
func (c *Cache) Cleanup(interval time.Duration) {
	ticker := time.NewTicker(interval)
	for range ticker.C {
		c.mu.Lock() // 获取写锁进行清理
		now := time.Now().UnixNano()
		for key, item := range c.items {
			if now > item.Expiration {
				delete(c.items, key)
			}
		}
		c.mu.Unlock()
	}
}

var mu sync.Mutex // 声明即可使用，mu 此时是未锁定的状态
mu.Lock()         // 正常使用
// ... 临界区代码
mu.Unlock()

package main

import (
	"fmt"
	"sync"
)

type BankAccount struct {
	balance float64
	mu      sync.Mutex // 每个账户都有自己的锁
}

func (a *BankAccount) Deposit(amount float64) {
	a.mu.Lock()         // 获取锁，进入临界区
	defer a.mu.Unlock() // 函数返回时自动释放锁，是很好的实践
    // 临界区开始
	a.balance += amount
    // 临界区结束
}

func (a *BankAccount) Withdraw(amount float64) bool {
	a.mu.Lock()
	defer a.mu.Unlock()

    // 检查余额是否足够也是一个需要保护的操作
	if a.balance >= amount {
		a.balance -= amount
		return true
	}
	return false
}

func (a *BankAccount) Balance() float64 {
	a.mu.Lock()
	defer a.mu.Unlock()

	return a.balance // 读取操作也需要加锁！
}

func main() {
	account := &BankAccount{balance: 100}

	var wg sync.WaitGroup

	// 启动 100 个 Goroutine 进行存款
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			account.Deposit(10)
		}()
	}

	// 启动 100 个 Goroutine 进行取款
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			account.Withdraw(10)
		}()
	}

	wg.Wait()
	fmt.Println("Final balance:", account.Balance()) // 结果应该是 100
}

package main

import (
	"fmt"
	"sync"
	"time"
)

const (
	numReaders = 1000
	readTimes  = 1000
)

var value int
var mutex sync.Mutex
var rwMutex sync.RWMutex

func main() {
	// 测试使用 Mutex 读
	value = 42
	start := time.Now()
	var wg sync.WaitGroup
	wg.Add(numReaders)
	for i := 0; i < numReaders; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < readTimes; j++ {
				mutex.Lock()
				_ = value // 模拟读操作
				mutex.Unlock()
			}
		}()
	}
	wg.Wait()
	mutexDuration := time.Since(start)

	// 测试使用 RWMutex 读
	value = 42
	start = time.Now()
	wg.Add(numReaders)
	for i := 0; i < numReaders; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < readTimes; j++ {
				rwMutex.RLock()
				_ = value // 模拟读操作
				rwMutex.RUnlock()
			}
		}()
	}
	wg.Wait()
	rwMutexDuration := time.Since(start)

	fmt.Printf("Mutex read: %v\n", mutexDuration)
	fmt.Printf("RWMutex read: %v\n", rwMutexDuration)
	fmt.Printf("RWMutex was %.2fx faster for reads\n", float64(mutexDuration)/float64(rwMutexDuration))
}

var dbConn *sql.DB

func getDB() *sql.DB {
    if dbConn == nil {
        dbConn, _ = sql.Open("mysql", "user:password@/dbname") // 非线程安全！
    }
    return dbConn
}
// 多个 Goroutine 同时调用 getDB() 可能会创建多个连接池，导致资源泄露。

package main

import (
	"database/sql"
	"fmt"
	"sync"

	_ "github.com/go-sql-driver/mysql"
)

var (
	db     *sql.DB
	dbOnce sync.Once // 专门用于初始化 db 的 Once
)

func getDB() *sql.DB {
    // 初始化操作被封装在 Do 的回调函数里
	dbOnce.Do(func() {
		fmt.Println("Initializing database connection...")
		var err error
        // 注意：这里使用了 :=，所以 db 是局部变量，必须赋值给全局的 db
		db, err = sql.Open("mysql", "user:password@tcp(localhost:3306)/testdb")
		if err != nil {
			panic(err)
		}
		db.SetMaxOpenConns(10)
	})
	return db
}

func main() {
	var wg sync.WaitGroup

    // 模拟 10 个并发请求，每个请求都需要获取数据库连接
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("Goroutine %d is getting DB instance...\n", id)
			conn := getDB()
            // 使用 conn 执行查询等操作...
			_ = conn // 假装使用一下
			fmt.Printf("Goroutine %d got it!\n", id)
		}(i)
	}
	wg.Wait()
    // 最终输出只会有一句 "Initializing database connection..."
}

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"sync"
)

type Config struct {
	ServerHost string `json:"server_host"`
	ServerPort int    `json:"server_port"`
	DebugMode  bool   `json:"debug_mode"`
}

var (
	appConfig Config
	configOnce sync.Once
)

func loadConfig() {
    // 这个函数可以被安全地多次调用，但实际加载动作只发生一次
	configOnce.Do(func() {
		fmt.Println("Loading configuration from file...")
		file, err := os.Open("config.json")
		if err != nil {
			panic(err)
		}
		defer file.Close()

		decoder := json.NewDecoder(file)
		err = decoder.Decode(&appConfig)
		if err != nil {
			panic(err)
		}
	})
}

func GetConfig() Config {
	loadConfig() // 在任何需要获取配置的地方调用，由 sync.Once 保证逻辑
	return appConfig
}

func main() {
    // 在多个地方获取配置，初始化只会发生一次
	cfg1 := GetConfig()
	cfg2 := GetConfig()

	fmt.Println(cfg1.ServerHost)
	fmt.Println(cfg2.ServerPort)
    // cfg1 和 cfg2 是同一个配置实例，加载操作只执行了一次
}

// 假设在第三方驱动包中：github.com/example/mydriver
package mydriver

import (
	"database/sql"
	"database/sql/driver"
)

type MyDriver struct{}

func (d MyDriver) Open(name string) (driver.Conn, error) { ... }

// 使用 init 函数在包被导入时自动注册驱动
func init() {
    sql.Register("mydriver", &MyDriver{})
}

// 在主程序中
package main

import (
    _ "github.com/example/mydriver" // 匿名导入，仅仅为了触发其 init 函数
    "database/sql"
)

func main() {
    // 此时 "mydriver" 驱动已经被注册，可以直接使用
    db, err := sql.Open("mydriver", "connection_string")
    // ...
}

package main

import (
	"fmt"
	"sync"
)

var (
	productCache map[int]string // 大型缓存
	cacheOnce    sync.Once
    cacheErr     error // 用于保存初始化过程中可能发生的错误
)

func loadProductCache() {
	// 模拟一个非常耗时的初始化操作
	fmt.Println("Loading massive product cache from DB... This takes time.")
	// ... 复杂的数据查询和处理逻辑 ...
	productCache = make(map[int]string)
	productCache[1] = "Laptop"
	productCache[2] = "Phone"
	// 如果发生错误，可以赋值给 cacheErr
	// cacheErr = someErrorFunction()
}

func GetProduct(id int) (string, error) {
    // 只有在第一次调用 GetProduct 时才会真正加载缓存
	cacheOnce.Do(loadProductCache)

    // 可以检查初始化是否出错
    // if cacheErr != nil {
    //     return "", cacheErr
    // }

	product, exists := productCache[id]
	if !exists {
		return "", fmt.Errorf("product not found")
	}
	return product, nil
}

func main() {
    // 程序快速启动，productCache 此时是 nil，未被初始化

    // 模拟多个并发请求
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(requestID int) {
            defer wg.Done()
            // 每个请求都会调用 GetProduct，但缓存只会加载一次
            prod, _ := GetProduct(1)
            fmt.Printf("Request %d got product: %s\n", requestID, prod)
        }(i)
    }
    wg.Wait()
}

package main

import (
	"fmt"
	"sync"
	"time"
)

func process(id int, wg *sync.WaitGroup) {
	defer wg.Done() // 确保在函数返回时通知 WaitGroup 任务完成

	fmt.Printf("Worker %d started\n", id)
	time.Sleep(time.Second) // 模拟耗时工作
	fmt.Printf("Worker %d done\n", id)
}

func main() {
	var wg sync.WaitGroup

	for i := 1; i <= 5; i++ {
		wg.Add(1) // 每启动一个 Goroutine，计数器加 1
		go process(i, &wg)
	}

	wg.Wait() // 阻塞，直到计数器归零
	fmt.Println("All workers completed. Proceeding to next step.")
}

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var m sync.Mutex
	cond := sync.NewCond(&m)
	var queue []int

	// 消费者 Goroutine
	go func() {
		for {
			cond.L.Lock()
            // 必须用循环检查条件，因为 Wait 返回时条件可能再次变为假（虚假唤醒）
			for len(queue) == 0 {
				fmt.Println("Consumer: waiting...")
				cond.Wait() // 释放锁并阻塞，被唤醒后重新获取锁
			}
			item := queue[0]
			queue = queue[1:]
			fmt.Printf("Consumer: processed %d\n", item)
			cond.L.Unlock()
		}
	}()

	// 生产者 Goroutine
	for i := 0; i < 5; i++ {
		time.Sleep(time.Second) // 模拟生产间隔
		cond.L.Lock()
		queue = append(queue, i)
		fmt.Printf("Producer: produced %d\n", i)
		cond.Signal() // 通知一个等待的消费者
		cond.L.Unlock()
	}

	time.Sleep(time.Second * 2) // 给消费者一点时间处理
}

package main

import (
	"bytes"
	"fmt"
	"sync"
)

var bufferPool = sync.Pool{
	New: func() interface{} {
        // 当 Pool 里没有对象时，调用此函数创建一个新对象
		fmt.Println("Creating a new buffer.")
		return &bytes.Buffer{}
	},
}

func logMessage(message string) {
	buf := bufferPool.Get().(*bytes.Buffer) // 从池中获取，断言为 *bytes.Buffer
	defer bufferPool.Put(buf)               // 使用完毕后放回池中

	buf.Reset()                     // 重置缓冲区，而不是创建一个新的
	buf.WriteString("LOG: ")
	buf.WriteString(message)

    // 模拟使用缓冲区的内容
	fmt.Println(buf.String())
}

func main() {
    // 多次调用，观察 "Creating a new buffer." 只打印了有限的次数
    // 后续调用会复用之前创建的对象
	for i := 0; i < 10; i++ {
		logMessage(fmt.Sprintf("Message %d", i))
	}
}

package main

import (
	"fmt"
	"sync"
)

var cache sync.Map // 开箱即用，无需初始化

func getFromDB(key string) (string, error) {
    // 模拟从数据库获取数据的昂贵操作
	fmt.Printf(" expensive DB call for %s\n", key)
	return "value_for_" + key, nil
}

func getCachedData(key string) (string, error) {
    // 首先尝试从并发安全的缓存中加载
	value, found := cache.Load(key)
	if found {
		fmt.Printf("Cache HIT for %s\n", key)
		return value.(string), nil // 需要进行类型断言
	}

    // 缓存未命中，从数据源获取
	valueFromDB, err := getFromDB(key)
	if err != nil {
		return "", err
	}

    // 将获取到的数据存储到缓存中
    // 使用 LoadOrStore 可以避免在极端的并发情况下重复写入
	actual, loaded := cache.LoadOrStore(key, valueFromDB)
	if loaded {
        // 如果 loaded 为 true，说明其他 Goroutine 已经抢先存储了
		fmt.Printf("Another goroutine stored the value for %s first\n", key)
	}
    // 返回最终存储的值（可能是我们存的，也可能是其他 Goroutine 存的）
	return actual.(string), nil
}

func main() {
	var wg sync.WaitGroup
	keys := []string{"key1", "key2", "key1", "key2"} // 模拟重复的请求

	for _, key := range keys {
		wg.Add(1)
		go func(k string) {
			defer wg.Done()
			val, _ := getCachedData(k)
			_ = val // 使用 val
		}(key)
	}
	wg.Wait()
}