var counter int

func main() {
    for i := 0; i < 1000; i++ {
        go func() { counter++ }()  // 存在數(shù)據(jù)競爭
    }
    time.Sleep(time.Second)
    fmt.Println(counter) // 結(jié)果不確定，通常 < 1000
}

狀態(tài)機(jī)簡圖：
  未鎖定(0) ──Lock()──? 已鎖定(1)
  已鎖定(1) ──Unlock()──? 未鎖定(0)
  已鎖定(1) ──Lock()──? 阻塞等待(信號量)

var mu sync.Mutex

mu.Lock()      // 加鎖，如果已被鎖定則阻塞等待
mu.Unlock()    // 解鎖，如果未鎖定則 panic
mu.TryLock()   // Go 1.18+ 嘗試加鎖，成功返回 true，失敗立即返回 false（非阻塞）

type SafeCounter struct {
    mu    sync.Mutex
    value int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

狀態(tài)模型：
  無鎖 ──RLock()──? 讀鎖（計數(shù)+1，可多個）
  無鎖 ──Lock() ──? 寫鎖（獨(dú)占）
  讀鎖 ──Lock() ──? 阻塞等待（所有讀鎖釋放后才可獲得寫鎖）
  寫鎖 ──RLock()──? 阻塞等待（寫鎖釋放后才可獲得讀鎖）

var rw sync.RWMutex

rw.RLock()       // 加讀鎖
rw.RUnlock()     // 解讀鎖
rw.Lock()        // 加寫鎖
rw.Unlock()      // 解寫鎖
rw.TryLock()     // Go 1.18+ 嘗試加寫鎖
rw.TryRLock()    // Go 1.18+ 嘗試加讀鎖

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

func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.data[key]
    return v, ok
}

func (c *Cache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

工作機(jī)制：
  Add(n)  ──? 計數(shù)器 += n
  Done()  ──? 計數(shù)器 -= 1
                    ↓
              計數(shù)器 == 0 時，喚醒所有 Wait()

var wg sync.WaitGroup

wg.Add(n)     // 增加計數(shù)器，必須在 goroutine 啟動前調(diào)用
wg.Done()     // 計數(shù)器減 1，等價于 Add(-1)
wg.Wait()     // 阻塞直到計數(shù)器歸零

func main() {
    var wg sync.WaitGroup
    urls := []string{"url1", "url2", "url3"}

    for _, url := range urls {
        wg.Add(1)                      // 在啟動 goroutine 前 Add
        go func(u string) {
            defer wg.Done()            // goroutine 結(jié)束時 Done
            fetch(u)
        }(url)
    }

    wg.Wait()                          // 等待所有 goroutine 完成
    fmt.Println("所有請求完成")
}

// 錯誤 1：Add 放在 goroutine 內(nèi)部
go func() {
    wg.Add(1)    // ? 可能 Wait() 先執(zhí)行，從而立即返回
    defer wg.Done()
    doWork()
}()

// 錯誤 2：計數(shù)變成負(fù)數(shù)
wg.Add(1)
wg.Done()
wg.Done()       // ? panic: sync: negative WaitGroup counter

// 錯誤 3：復(fù)制 WaitGroup
var wg2 sync.WaitGroup
wg2 = wg        // ? 拷貝后語義獨(dú)立，應(yīng)傳指針

var once sync.Once

once.Do(func() {
    // 只會執(zhí)行一次的代碼
})

type Config struct {
    DBHost string
    DBPort int
}

var (
    instance *Config
    once     sync.Once
)

func GetConfig() *Config {
    once.Do(func() {
        instance = &Config{
            DBHost: os.Getenv("DB_HOST"),
            DBPort: 3306,
        }
    })
    return instance
}

cond := sync.NewCond(&sync.Mutex{})

cond.L.Lock()        // 獲取關(guān)聯(lián)的鎖
cond.Wait()          // 等待條件（釋放鎖、掛起、被喚醒后重新獲取鎖）
cond.Signal()        // 喚醒一個等待的 goroutine
cond.Broadcast()     // 喚醒所有等待的 goroutine
cond.L.Unlock()      // 釋放鎖

type BoundedQueue struct {
    cond     *sync.Cond
    items    []interface{}
    capacity int
}

func NewBoundedQueue(cap int) *BoundedQueue {
    return &BoundedQueue{
        cond:     sync.NewCond(&sync.Mutex{}),
        capacity: cap,
    }
}

func (q *BoundedQueue) Put(item interface{}) {
    q.cond.L.Lock()
    defer q.cond.L.Unlock()

    for len(q.items) == q.capacity {  // 必須用 for 而非 if
        q.cond.Wait()                   // 等待隊列有空位
    }
    q.items = append(q.items, item)
    q.cond.Signal()                     // 喚醒等待的消費(fèi)者
}

func (q *BoundedQueue) Get() interface{} {
    q.cond.L.Lock()
    defer q.cond.L.Unlock()

    for len(q.items) == 0 {            // 必須用 for 而非 if
        q.cond.Wait()                   // 等待隊列有數(shù)據(jù)
    }
    item := q.items[0]
    q.items = q.items[1:]
    q.cond.Signal()                     // 喚醒等待的生產(chǎn)者
    return item
}

var pool sync.Pool

pool.New = func() interface{} {  // 池為空時的工廠函數(shù)
    return &MyStruct{}
}

obj := pool.Get()                 // 獲取對象（可能為 nil）
pool.Put(obj)                     // 歸還對象

var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func ProcessJSON(data []byte) (string, error) {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufferPool.Put(buf)
    }()

    if err := json.Compact(buf, data); err != nil {
        return "", err
    }
    return buf.String(), nil
}

var sm sync.Map

sm.Store(key, value)           // 存儲
sm.Load(key)                   // 加載，返回 (value, bool)
sm.LoadOrStore(key, value)     // 存在則返回，不存在則存儲
sm.Delete(key)                 // 刪除
sm.LoadAndDelete(key)          // 加載并刪除
sm.Range(func(key, value interface{}) bool { ... })  // 遍歷

// 適合的場景：緩存系統(tǒng)配置，key 基本不變，寫操作極少
var configCache sync.Map

func GetConfig(key string) (string, bool) {
    v, ok := configCache.Load(key)
    if !ok {
        return "", false
    }
    return v.(string), true
}

func SetConfig(key, value string) {
    configCache.Store(key, value)
}

// 不適合的場景：key 動態(tài)變化
// 下面這種情況用 map + RWMutex 更好
// go func() {
//     for i := 0; i < 1000000; i++ {
//         sm.Store(strconv.Itoa(i), i)  // 每次新 key 都觸發(fā) dirty map 復(fù)制
//     }
// }()

// 基本類型原子操作
atomic.AddInt32(&counter, 1)         // 原子加法，返回新值
atomic.LoadInt32(&counter)           // 原子讀
atomic.StoreInt32(&counter, 100)     // 原子寫
atomic.SwapInt32(&counter, 200)      // 原子交換，返回舊值
atomic.CompareAndSwapInt32(&c, 0, 1) // CAS：如果 c==0，設(shè)為 1，返回是否成功

// Go 1.19+ 泛型類型（更推薦）
var counter atomic.Int32
counter.Add(1)       // 原子加法
counter.Load()       // 原子讀
counter.Store(100)   // 原子寫
counter.Swap(200)    // 原子交換
counter.CompareAndSwap(0, 1) // CAS

// 其他泛型類型
var flag atomic.Bool       // 原子布爾
var ptr atomic.Pointer[T]  // 原子指針（Go 1.19+）
var val atomic.Value       // 原子任意類型（Go 1.4+，存在寫入類型不一致的 panic 風(fēng)險）

// 自旋鎖的簡化實(shí)現(xiàn)（僅示意，實(shí)際用 sync.Mutex）
type SpinLock struct {
    flag atomic.Int32
}

func (s *SpinLock) Lock() {
    for !s.flag.CompareAndSwap(0, 1) {
        runtime.Gosched()  // 讓出 CPU，避免空轉(zhuǎn)耗盡
    }
}

func (s *SpinLock) Unlock() {
    s.flag.Store(0)
}

type Config struct {
    DBHost string
    DBPort int
}

var currentConfig atomic.Pointer[Config]

func init() {
    // 初始化
    currentConfig.Store(&Config{DBHost: "localhost", DBPort: 3306})
    // 啟動配置監(jiān)聽
    go watchConfig()
}

// GetConfig 完全無鎖讀取
func GetConfig() *Config {
    return currentConfig.Load()
}

func watchConfig() {
    for newConf := range configChan {
        currentConfig.Store(newConf) // 原子更新指針
    }
}

// 1. Channel 作為信號量（限流并發(fā)數(shù)為 5）
sem := make(chan struct{}, 5)
for _, task := range tasks {
    sem <- struct{}{}          // 獲取信號量，滿則阻塞
    go func(t Task) {
        defer func() { <-sem }() // 釋放信號量
        process(t)
    }(task)
}

// 2. close channel 實(shí)現(xiàn)一鍵通知所有 goroutine 退出
stopCh := make(chan struct{})
for i := 0; i < 10; i++ {
    go func() {
        for {
            select {
            case <-stopCh:
                return
            default:
                doWork()
            }
        }
    }()
}
close(stopCh) // 所有 goroutine 同時收到信號

// 3. 超時 + 限流 + 取消 組合
select {
case result := <-resultCh:
    handle(result)
case <-time.After(3 * time.Second):
    log.Println("超時")
case <-ctx.Done():
    log.Println("取消")
}

// 4. for-range 優(yōu)雅等待
ch := make(chan int, 10)
go func() {
    for v := range ch {          // channel 關(guān)閉后自動退出
        fmt.Println(v)
    }
}()

func HandleRequest(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel()

    // 并行查詢多個數(shù)據(jù)源
    userCh := fetchUser(ctx, userID)
    orderCh := fetchOrders(ctx, userID)

    var user *User
    var orders []Order

    for i := 0; i < 2; i++ {
        select {
        case u := <-userCh:
            user = u
        case o := <-orderCh:
            orders = o
        case <-ctx.Done():   // 超時或取消
            http.Error(w, "請求超時", http.StatusGatewayTimeout)
            return
        }
    }
}

func fetchUser(ctx context.Context, id string) <-chan *User {
    ch := make(chan *User, 1)
    go func() {
        defer close(ch)
        // 模擬 DB 查詢
        result := db.QueryContext(ctx, "SELECT * FROM users WHERE id = ?", id)
        ch <- result
    }()
    return ch
}

// 使用 go-redis 實(shí)現(xiàn)分布式鎖
type RedisLock struct {
    client *redis.Client
    key    string
    value  string // 隨機(jī)值，用于安全釋放
    ttl    time.Duration
}

func NewRedisLock(client *redis.Client, key string, ttl time.Duration) *RedisLock {
    return &RedisLock{
        client: client,
        key:    key,
        value:  uuid.New().String(),
        ttl:    ttl,
    }
}

func (l *RedisLock) TryLock(ctx context.Context) (bool, error) {
    return l.client.SetNX(ctx, l.key, l.value, l.ttl).Result()
}

// Unlock 使用 Lua 腳本保證原子性：只有 value 匹配時才刪除
var unlockScript = redis.NewScript(`
    if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("DEL", KEYS[1])
    else
        return 0
    end
`)

func (l *RedisLock) Unlock(ctx context.Context) error {
    return unlockScript.Run(ctx, l.client, []string{l.key}, l.value).Err()
}

// 場景 1：Lock 順序不一致
// goroutine A: Lock(a) → Lock(b)
// goroutine B: Lock(b) → Lock(a)
// → ABBA 死鎖

// 場景 2：channel 循環(huán)等待
ch1, ch2 := make(chan int), make(chan int)
go func() { ch1 <- <-ch2 }()
go func() { ch2 <- <-ch1 }()
// → 互相等待對方寫入

// 場景 3：Mutex 不可重入
mu.Lock()
mu.Lock() // 死鎖！同一 goroutine 重復(fù)加鎖

// 場景 4：sync.Cond 等待信號丟失
cond.L.Lock()
// Signal 在其他 goroutine 中已發(fā)出，但當(dāng)前 goroutine 還沒 Wait
cond.Wait() // 永遠(yuǎn)等不到下一個 Signal