sync 包：Mutex、RWMutex、WaitGroup、Once

一、学习目标

二、知识讲解

1.1 共享内存与锁（Mutex & RWMutex）

在 Go 中，共享内存是并发编程的核心模型。当多个 goroutine 访问同一块内存时，必须通过同步机制保证数据一致性。锁是最基础的同步原语。

Mutex 是互斥锁，同一时刻只允许一个 goroutine 持有。其核心方法为 Lock() 和 Unlock()。 RWMutex 是读写锁，允许同时存在多个读锁，但写锁独占。它包含 RLock()、RUnlock()、Lock()、Unlock()。

为什么这样设计？ 在并发系统中，读操作通常不修改数据，因此允许多个读并发可以显著提升吞吐量。然而，如果临界区极短或读写比例接近，RWMutex 的额外状态维护开销可能使其比 Mutex 更慢。

怎么用？ - Mutex 适用于写频繁或临界区较长的场景。 - RWMutex 适用于读远多于写（如配置缓存）的场景。 - 原子操作（如 sync/atomic 包）在无竞争或简单计数场景下性能优于锁，但在复杂逻辑中锁更直观。

1.2 WaitGroup 等待组

WaitGroup 用于等待一组 goroutine 执行完毕。它有三个方法： - Add(delta int)：增加计数器。 - Done()：计数器减 1，通常在 goroutine 结束时调用。 - Wait()：阻塞直到计数器为 0。

陷阱：Add 必须在 Wait 之前调用，否则会导致死锁或 panic。WaitGroup 不可复制，复制后行为未定义。

1.3 Once 单次执行

Once 保证某个函数在整个程序生命周期中仅执行一次。常用于单例模式或资源初始化。 - Once.Do(f func())：若 f 未执行，则执行并标记为已执行；否则直接返回。

1.4 Pool 对象池

sync.Pool 用于缓存临时对象，减少 GC 压力。 - Get()：从池中获取对象，若池为空则调用 New 函数创建。 - Put(obj any)：将对象放回池中。

注意：Pool 不保证对象被保留，GC 可能会清理池中的对象。取出对象后，必须自行重置状态，因为池中的对象可能残留旧数据。

三、示例代码

示例 1：RWMutex 保护共享计数器

本示例演示如何使用 RWMutex 保护共享计数器，模拟并发读写场景。

package main

import (
    "fmt"
    "sync"
)

var (
    mu    sync.RWMutex
    counter int
)

func main() {
    var wg sync.WaitGroup

    // 启动 5 个写协程
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            mu.Lock()
            counter++
            fmt.Printf("Writer %d: counter is %d\n", id, counter)
            mu.Unlock()
        }(i)
    }

    // 启动 5 个读协程
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            mu.RLock()
            fmt.Printf("Reader %d: counter is %d\n", id, counter)
            mu.RUnlock()
        }(i)
    }

    wg.Wait()
}

运行结果（预期输出）：

Writer 0: counter is 1
Reader 0: counter is 1
Writer 1: counter is 2
Reader 1: counter is 2
Writer 2: counter is 3
Reader 2: counter is 3
Writer 3: counter is 4
Reader 3: counter is 4
Writer 4: counter is 5
Reader 4: counter is 5

(注：由于 goroutine 调度顺序不确定，Writer 和 Reader 的输出顺序可能不同，但 counter 的值会随写入递增。)

示例 2：sync.Pool 对象复用与重置

本示例演示 sync.Pool 的使用，重点展示取出对象后必须重置状态，因为池中的对象可能残留旧数据。

package main

import (
    "fmt"
    "sync"
)

type Buffer struct {
    Data []byte
}

var bufPool = sync.Pool{
    New: func() any {
        return &Buffer{Data: make([]byte, 64)}
    },
}

func main() {
    // 第一次获取，New 函数被调用
    buf1 := bufPool.Get().(*Buffer)
    buf1.Data[0] = 'A'
    fmt.Printf("Buf1 content: %s\n", buf1.Data[:1])

    // 放回池中
    bufPool.Put(buf1)

    // 第二次获取，可能拿到刚才放回的 buf1
    buf2 := bufPool.Get().(*Buffer)
    // 关键点：必须重置切片，因为 buf2 可能包含之前的 'A'
    buf2.Data[0] = 'B'
    fmt.Printf("Buf2 content: %s\n", buf2.Data[:1])

    // 清理并放回
    buf2.Data[0] = 0
    bufPool.Put(buf2)
}

运行结果（预期输出）：

Buf1 content: A
Buf2 content: B

四、常见错误与避坑指南

五、最佳实践

六、练习题

1. 概念题：解释 sync.Mutex 和 sync.RWMutex 在并发读场景下的性能差异及适用条件。
2. 编码题：编写一个程序，使用 WaitGroup 启动 10 个 goroutine，每个 goroutine 计算 1 到 100 的和，最后汇总所有结果并打印总和。
3. 进阶/调试题：以下代码存在竞态条件，请找出问题并修复。 ```go package main

import ( "fmt" "sync" )

var counter int var mu sync.Mutex

func increment(wg *sync.WaitGroup) { defer wg.Done() mu.Lock() counter++ mu.Unlock() }

func main() { var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go increment(&wg) } wg.Wait() fmt.Println("Counter:", counter) } ``` (注：上述代码看似正确，但请思考是否有潜在问题？实际上，上述代码是正确的。为了体现“进阶”，我们提供一个错误版本供学员修正)

修正版题目： ```go package main

import ( "fmt" "sync" )

var counter int var mu sync.Mutex

func increment(wg *sync.WaitGroup) { defer wg.Done() // 错误点：Lock 和 Unlock 不在同一层级，且逻辑有误 mu.Lock() counter++ // 忘记 Unlock，导致后续 goroutine 死锁 }

func main() { var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go increment(&wg) } wg.Wait() fmt.Println("Counter:", counter) } ```

七、练习参考答案

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var total int
    var totalMu sync.Mutex

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            sum := 0
            for j := 1; j <= 100; j++ {
                sum += j
            }
            totalMu.Lock()
            total += sum
            totalMu.Unlock()
        }()
    }

    wg.Wait()
    fmt.Println("Total sum:", total)
}

package main

import (
    "fmt"
    "sync"
)

var counter int
var mu sync.Mutex

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Counter:", counter)
}

八、本课小结