1
var (
2
    mu    sync.Mutex
3
    value int
4
)
5

6
func update(newVal int) {
7
    mu.Lock()
8
    defer mu.Unlock()
9
    value = newVal
10
}
11

12
func read() int {
13
    mu.Lock()
14
    defer mu.Unlock()
15
    return value
16
}

1
// sync.Mutex 源码简化
2
// 源码参考：https://github.com/golang/go/blob/go1.25.0/src/sync/mutex.go
3
// 源码参考：https://github.com/golang/go/blob/go1.25.0/src/sync/mutex.go
4
type Mutex struct {
5
    state int32  // 32位状态
6
    sema  uint32 // 信号量
7
}
8

9
// 状态位
10
const (
11
    mutexLocked = 1 << iota  // 1: 锁被持有
12
    mutexWoken               // 2: 有等待者被唤醒
13
    mutexStarving            // 4: 饥饿模式
14
    mutexWaiterShift = iota // 等待者数量偏移
15
)

1
// 正常模式（默认）：等待者 FIFO，先来先服务
2
// 饥饿模式：锁直接交给等待队列尾部
3
//
4
// 切换条件：
5
// - 等待超过 1ms 切换到饥饿模式
6
// - 等待队列空了切换回正常模式

1
// 常见错误：在锁外部访问共享数据
2
mu.Lock()
3
value = 100  // 这里有锁
4
fmt.Println(value)
5
mu.Unlock()
6

7
value = 200  // 这里没有锁！危险！
8

9
// 另一个常见错误：读也在锁外，同样是数据竞争
10
mu.Lock()
11
value = 100
12
mu.Unlock()
13
fmt.Println(value)  // 锁外读取也有竞争！另一个 goroutine 可能正在写入
14

15
// 正确做法：所有对共享变量的读写都必须在锁内
16
mu.Lock()
17
value = 100
18
v := value  // 在锁内拷贝
19
mu.Unlock()
20
fmt.Println(v)  // 使用局部副本，安全

1
var (
2
    mu    sync.RWMutex
3
    data  map[string]string
4
)
5

6
func read(key string) string {
7
    mu.RLock()         // 读锁
8
    defer mu.RUnlock()
9
    return data[key]
10
}
11

12
func write(key, value string) {
13
    mu.Lock()          // 写锁
14
    defer mu.Unlock()
15
    data[key] = value
16
}

1
// 读多写少场景：RWMutex 优于 Mutex
2
// 读写锁：多个读者或单一写者
3
// 互斥锁：多个写者或单一写者

1
// 源码参考：https://github.com/golang/go/blob/go1.25.0/src/sync/rwmutex.go
2
type RWMutex struct {
3
    w           Mutex  // 写锁入口
4
    writerSem   uint32 // 写者信号量
5
    readerSem   uint32 // 读者信号量
6
    readerCount atomic.Int32 // 当前读者数
7
    readerWait  atomic.Int32 // 等待的写者数
8
}

1
var wg sync.WaitGroup
2

3
func main() {
4
    for i := 0; i < 3; i++ {
5
        wg.Add(1)  // 计数 +1
6
        go func(id int) {
7
            defer wg.Done()  // 计数 -1
8
            process(id)
9
        }(i)
10
    }
11

12
    wg.Wait()  // 阻塞直到计数归零
13
    fmt.Println("All done")
14
}

1
// 模式1：启动 workers
2
func processAll(items []Item) error {
3
    var wg sync.WaitGroup
4
    errCh := make(chan error, len(items))
5

6
    for _, item := range items {
7
        wg.Add(1)
8
        go func(item Item) {
9
            defer wg.Done()
10
            if err := process(item); err != nil {
11
                errCh <- err
12
            }
13
        }(item)
14
    }
15

16
    wg.Wait()
17
    close(errCh)
18

19
    var errs []error
20
    for err := range errCh {
21
        errs = append(errs, err)
22
    }
23
    return errors.Join(errs...)
24
}
25

26
// 模式2：扇出
27
func fanOut(ctx context.Context, tasks []Task) error {
28
    var wg sync.WaitGroup
29
    for _, task := range tasks {
30
        wg.Add(1)
31
        go func(t Task) {
32
            defer wg.Done()
33
            execute(ctx, t)
34
        }(task)
35
    }
36
    wg.Wait()
37
    return nil
38
}

1
// 常见错误：Add 和 Done 不配对
2
func wrong() {
3
    wg.Add(1)      // +1
4
    go func() {
5
        defer wg.Done() // -1
6
        // ...
7
    }()
8
    // 如果 goroutine panic，Done 不会执行
9
    wg.Wait()  // 永远等待！
10
}
11

12
// 正确做法：使用 defer
13
func correct() {
14
    wg.Add(1)
15
    go func() {
16
        defer wg.Done()  // 确保执行
17
        // ...
18
    }()
19
    wg.Wait()
20
}

1
var (
2
    once   sync.Once
3
    config *Config
4
)
5

6
func getConfig() *Config {
7
    once.Do(func() {
8
        config = loadConfig()  // 只执行一次
9
    })
10
    return config
11
}

1
// 源码参考：https://github.com/golang/go/blob/go1.25.0/src/sync/once.go
2
type Once struct {
3
    done atomic.Uint32
4
    m    Mutex
5
}
6

7
func (o *Once) Do(f func()) {
8
    if o.done.Load() == 0 {  // 快速路径
9
        o.doSlow(f)
10
    }
11
}
12

13
func (o *Once) doSlow(f func()) {
14
    o.m.Lock()
15
    defer o.m.Unlock()
16
    if o.done.Load() == 0 {  // 双重检查
17
        f()
18
        o.done.Store(1)
19
    }
20
}

1
// 应用1：单例模式
2
type DB struct {
3
    conn *sql.DB
4
}
5

6
var (
7
    db     *DB
8
    dbOnce sync.Once
9
)
10

11
func GetDB() *DB {
12
    dbOnce.Do(func() {
13
        db = &DB{conn: connect()}
14
    })
15
    return db
16
}
17

18
// 应用2：初始化
19
type Service struct {
20
    once   sync.Once
21
    client *http.Client
22
}
23

24
func (s *Service) init() {
25
    s.once.Do(func() {
26
        s.client = &http.Client{
27
            Timeout: 30 * time.Second,
28
            Transport: &http.Transport{
29
                MaxIdleConns: 100,
30
            },
31
        }
32
    })
33
}

1
var (
2
    cond   = sync.NewCond(&sync.Mutex{})
3
    ready  bool
4
)
5

6
func waitForReady() {
7
    cond.L.Lock()
8
    for !ready {
9
        cond.Wait()  // 阻塞并释放锁
10
    }
11
    cond.L.Unlock()
12
    fmt.Println("Ready!")
13
}
14

15
func setReady() {
16
    cond.L.Lock()
17
    ready = true
18
    cond.L.Unlock()
19
    cond.Signal()  // 唤醒一个等待者
20
    // 或 cond.Broadcast() 唤醒所有
21
}

1
// cond.Wait() 内部操作：
2
// 1. 释放锁
3
// 2. 阻塞等待信号
4
// 3. 重新获取锁
5

6
// 因此必须在循环中使用：
7
for !condition {
8
    cond.Wait()  // 自动释放和重新获取锁
9
}

1
// 应用：实现简单的信号量
2
type Semaphore struct {
3
    cond  *sync.Cond
4
    count int
5
    max   int
6
}
7

8
func NewSemaphore(max int) *Semaphore {
9
    return &Semaphore{
10
        cond: sync.NewCond(&sync.Mutex{}),
11
        max:  max,
12
    }
13
}
14

15
func (s *Semaphore) Acquire() {
16
    s.cond.L.Lock()
17
    for s.count >= s.max {
18
        s.cond.Wait()
19
    }
20
    s.count++
21
    s.cond.L.Unlock()
22
}
23

24
func (s *Semaphore) Release() {
25
    s.cond.L.Lock()
26
    s.count--
27
    s.cond.Signal()  // 唤醒一个等待者
28
    s.cond.L.Unlock()
29
}

1
var bufferPool = sync.Pool{
2
    New: func() any {
3
        return &bytes.Buffer{}
4
    },
5
}
6

7
func getBuffer() *bytes.Buffer {
8
    buf := bufferPool.Get().(*bytes.Buffer)
9
    buf.Reset()  // 重置状态
10
    return buf
11
}
12

13
func putBuffer(buf *bytes.Buffer) {
14
    bufferPool.Put(buf)
15
}

1
// 适合：高频分配/释放的轻量级对象
2
// - bytes.Buffer 重用
3
// - 临时解析器
4
// - 连接缓冲
5

6
// 不适合：需要保持状态的对象
7
// - 数据库连接（用 sql.DB）
8
// - 需要 pool.Get() 返回的对象，可能被其他人拿走

1
//  Pool 中的对象可能会被 GC 回收
2
// 不要依赖 Pool 中对象的长期存在
3

4
// 错误：缓存连接
5
var connPool = sync.Pool{
6
    New: func() any {
7
        return createExpensiveConnection()
8
    },
9
}
10

11
// 因为：GC 时 Pool 会被清空，连接丢失
12

13
// 正确：用专门的池管理（如 google.golang.org/grpc/balancer_conn_state_evaluator）

1
var m sync.Map
2

3
// 存储
4
m.Store("key", "value")
5

6
// 读取
7
value, ok := m.Load("key")
8

9
// 删除
10
m.Delete("key")
11

12
// 遍历
13
m.Range(func(key, value any) bool {
14
    fmt.Println(key, value)
15
    return true  // 返回 false 停止遍历
16
})
17

18
// 加载或存储
19
value, loaded := m.LoadOrStore("key", "newValue")
20
// 如果 key 存在，loaded=true，value 是旧值
21
// 如果 key 不存在，loaded=false，value 是新值

1
// sync.Map 适合的场景：
2
// 1. 读多写少且 key 相对稳定
3
// 2. 多个 goroutine 独立读写不同的 key
4
// 3. 需要并发安全的 map
5

6
// 不适合的场景：
7
// 1. 需要对同一个 key 进行读写
8
// 2. 写多读少（用 Mutex + map）
9
// 3. 需要原子操作（如 LoadAndDelete）

1
// 读多写少：sync.Map 优势明显
2
// 写多读少：Mutex + map 更好
3

4
// benchmark 结果（仅供参考）
5
// 读多写少：sync.Map 比 Mutex+map 快 3-10 倍
6
// 写多读少：Mutex+map 比 sync.Map 快 2-5 倍

1
import "sync/atomic"
2

3
var counter atomic.Int64
4

5
// 原子加
6
counter.Add(1)
7

8
// 原子加载
9
n := counter.Load()
10

11
// 原子存储
12
counter.Store(100)
13

14
// 原子交换（返回旧值）
15
old := counter.Swap(200)
16

17
// 原子比较并交换
18
swapped := counter.CompareAndSwap(100, 200)
19
// 只有当 counter == 100 时才设置为 200

1
type Config struct {
2
    Timeout int
3
}
4

5
var config atomic.Value
6

7
// 存储
8
config.Store(&Config{Timeout: 30})
9

10
// 加载
11
cfg := config.Load().(*Config)

1
// 应用1：实现无锁队列（简单版）
2
type LockFreeQueue struct {
3
    head atomic.Pointer[node]
4
    tail atomic.Pointer[node]
5
}
6

7
// 应用2：实现计数器
8
type Counter struct {
9
    count atomic.Int64
10
}
11

12
func (c *Counter) Inc() {
13
    c.count.Add(1)
14
}
15

16
func (c *Counter) Get() int64 {
17
    return c.count.Load()
18
}