一文带你掌握Go语言后端的锁机制

var counter int

func main() {
    for i := 0; i < 1000; i++ {
        go func() { counter++ }()  // 存在数据竞争
    }
    time.Sleep(time.Second)
    fmt.Println(counter) // 结果不确定，通常 < 1000
}

状态机简图：
  未锁定(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
}

状态模型：
  无锁 ──RLock()──▶ 读锁（计数+1，可多个）
  无锁 ──Lock() ──▶ 写锁（独占）
  读锁 ──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
}

工作机制：
  Add(n)  ──▶ 计数器 += n
  Done()  ──▶ 计数器 -= 1
                    ↓
              计数器 == 0 时，唤醒所有 Wait()

var wg sync.WaitGroup

wg.Add(n)     // 增加计数器，必须在 goroutine 启动前调用
wg.Done()     // 计数器减 1，等价于 Add(-1)
wg.Wait()     // 阻塞直到计数器归零

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 结束时 Done
            fetch(u)
        }(url)
    }

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

// 错误 1：Add 放在 goroutine 内部
go func() {
    wg.Add(1)    // ❌ 可能 Wait() 先执行，从而立即返回
    defer wg.Done()
    doWork()
}()

// 错误 2：计数变成负数
wg.Add(1)
wg.Done()
wg.Done()       // ❌ panic: sync: negative WaitGroup counter

// 错误 3：复制 WaitGroup
var wg2 sync.WaitGroup
wg2 = wg        // ❌ 拷贝后语义独立，应传指针

var once sync.Once

once.Do(func() {
    // 只会执行一次的代码
})

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()        // 获取关联的锁
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()                     // 唤醒等待的消费者
}

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

    for len(q.items) == 0 {            // 必须用 for 而非 if
        q.cond.Wait()                   // 等待队列有数据
    }
    item := q.items[0]
    q.items = q.items[1:]
    q.cond.Signal()                     // 唤醒等待的生产者
    return item
}

var pool sync.Pool

pool.New = func() interface{} {  // 池为空时的工厂函数
    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 { ... })  // 遍历

// 适合的场景：缓存系统配置，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 动态变化
// 下面这种情况用 map + RWMutex 更好
// go func() {
//     for i := 0; i < 1000000; i++ {
//         sm.Store(strconv.Itoa(i), i)  // 每次新 key 都触发 dirty map 复制
//     }
// }()

// 基本类型原子操作
atomic.AddInt32(&counter, 1)         // 原子加法，返回新值
atomic.LoadInt32(&counter)           // 原子读
atomic.StoreInt32(&counter, 100)     // 原子写
atomic.SwapInt32(&counter, 200)      // 原子交换，返回旧值
atomic.CompareAndSwapInt32(&c, 0, 1) // CAS：如果 c==0，设为 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 风险）

// 自旋锁的简化实现（仅示意，实际用 sync.Mutex）
type SpinLock struct {
    flag atomic.Int32
}

func (s *SpinLock) Lock() {
    for !s.flag.CompareAndSwap(0, 1) {
        runtime.Gosched()  // 让出 CPU，避免空转耗尽
    }
}

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})
    // 启动配置监听
    go watchConfig()
}

// GetConfig 完全无锁读取
func GetConfig() *Config {
    return currentConfig.Load()
}

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

// 1. Channel 作为信号量（限流并发数为 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 实现一键通知所有 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 优雅等待
ch := make(chan int, 10)
go func() {
    for v := range ch {          // channel 关闭后自动退出
        fmt.Println(v)
    }
}()

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

    // 并行查询多个数据源
    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 实现分布式锁
type RedisLock struct {
    client *redis.Client
    key    string
    value  string // 随机值，用于安全释放
    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 循环等待
ch1, ch2 := make(chan int), make(chan int)
go func() { ch1 <- <-ch2 }()
go func() { ch2 <- <-ch1 }()
// → 互相等待对方写入

// 场景 3：Mutex 不可重入
mu.Lock()
mu.Lock() // 死锁！同一 goroutine 重复加锁

// 场景 4：sync.Cond 等待信号丢失
cond.L.Lock()
// Signal 在其他 goroutine 中已发出，但当前 goroutine 还没 Wait
cond.Wait() // 永远等不到下一个 Signal