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
type Mutex struct {
4
    state int32  // 32 位状态
5
    sema  uint32 // 信号量
6
}
7

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

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
type Mutex struct {
2
    state int32
3
    sema  uint32
4
    // noCopy noCopy  // 隐藏在源码里，go vet 据此报警
5
}

1
$ go vet ./...
2
example.go:12:7: assignment copies lock value to z: sync.Mutex

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
func (rw *RWMutex) Lock() {
2
    // 先获取 w 锁，防止多个写者竞争
3
    rw.w.Lock()
4
    // 标记"写锁已获取"，阻止新读者进入
5
    r := rw.readerCount.Add(-rwmutexMaxReaders) + rwmutexMaxReaders
6
    if r != 0 {
7
        // 还有读者没退出，等待
8
        rw.readerWait.Store(r)
9
        runtime_Semacquire(&rw.writerSem)
10
    }
11
}

1
func (rw *RWMutex) RUnlock() {
2
    r := rw.readerCount.Add(-1)
3
    if r < 0 {
4
        // readerCount 为负数，说明有写者在等
5
        if rw.readerWait.Add(-1) == 0 {
6
            // 最后一个等待的读者退出了，唤醒写者
7
            runtime_Semrelease(&rw.writerSem, false, 0)
8
        }
9
    }
10
}

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
func (wg *WaitGroup) Add(delta int) {
2
    state := wg.state.Add(uint64(delta) << 32)
3
    v := int32(state >> 32)  // counter
4
    w := uint32(state)        // waiter
5

6
    if v < 0 {
7
        panic("sync: WaitGroup is reused before previous Wait has returned")
8
    }
9
    // counter 归零且有等待者，释放信号量
10
    if v == 0 && w > 0 {
11
        wg.state.Store(0)
12
        for ; w != 0; w-- {
13
            runtime_Semrelease(&wg.sema, false, 0)
14
        }
15
    }
16
}

1
func (wg *WaitGroup) Wait() {
2
    for {
3
        state := wg.state.Load()
4
        v := int32(state >> 32)
5
        if v == 0 {
6
            return  // counter 已经是 0，无需等待
7
        }
8
        // 尝试增加 waiter 计数
9
        if wg.state.CompareAndSwap(state, state+1) {
10
            runtime_Semacquire(&wg.sema)
11
            return
12
        }
13
    }
14
}

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
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
// 错误：用 Pool 缓存数据库连接
2
var connPool = sync.Pool{
3
    New: func() any {
4
        return createExpensiveConnection()
5
    },
6
}
7
// GC 时连接被清除，下次 Get() 创建新连接，连接池形同虚设
8

9
// 正确：用专门的连接管理（sql.DB、grpc 连接池等）

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
func (m *Map) Load(key any) (value any, ok bool) {
2
    read := m.read.Load().(readOnly)
3
    e, ok := read.m[key]
4
    if !ok && read.amended {
5
        // read 中没有，但 dirty 可能有
6
        m.mu.Lock()
7
        read = m.read.Load().(readOnly)
8
        e, ok = read.m[key]
9
        if !ok && read.amended {
10
            e, ok = m.dirty[key]
11
            m.missLocked()  // 增加未命中计数
12
        }
13
        m.mu.Unlock()
14
    }
15
    if !ok {
16
        return nil, false
17
    }
18
    return e.load()
19
}

1
// 读多写少：sync.Map 比 Mutex+map 快 3-10 倍
2
// 写多读少：Mutex+map 比 sync.Map 快 2-5 倍
3
//
4
// 原因：sync.Map 读操作直接访问 read map（atomic load），
5
// 而 Mutex+map 每次读都要加锁。但 sync.Map 写操作需要
6
// 提升 dirty → read，涉及全量复制，写多时开销惊人。

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)