Go 语言的sync包提供了基本的同步原语，如互斥锁、条件变量、读写锁等，用于处理并发编程中的同步问题。本文详细介绍sync包中的几个重要组件：sync.Cond、sync.WaitGroup、sync.Pool、sync/atomic、sync.Mutex、sync.RWMutex和sync.Once。
sync.Mutex（互斥锁）

sync.Mutex是互斥锁，用于保护共享资源，保证同一时间只有一个协程(goroutine)可以访问该资源。

var mu sync.Mutex
var count int

func increment() {
    mu.Lock() // 请求锁定
    count++   // 安全地增加计数
    mu.Unlock() // 释放锁
}

sync.RWMutex（读写锁）

sync.RWMutex是读写锁，允许多个协程同时读取共享资源，但同一时间只能有一个协程可以写入。

var rwMu sync.RWMutex
var data map[string]int

func read(key string) int {
    rwMu.RLock() // 请求读锁
    value := data[key]
    rwMu.RUnlock() // 释放读锁
    return value
}

func write(key string, value int) {
    rwMu.Lock() // 请求写锁
    data[key] = value
    rwMu.Unlock() // 释放写锁
}

sync.WaitGroup（等待组）

sync.WaitGroup用于等待一组协程的结束。主协程可以调用Wait()阻塞，直到所有的子协程执行完毕。

var wg sync.WaitGroup

func worker(id int) {
    defer wg.Done() // 结束时通知WaitGroup
    // 执行工作...
}

func main() {
    for i := 0; i < 5; i++ {
        wg.Add(1) // 添加一个协程
        go worker(i)
    }
    wg.Wait() // 等待所有协程完成
}

sync.Once（只执行一次）

sync.Once保证在多协程环境下某个函数只执行一次。

var once sync.Once
var config map[string]string

func loadConfig() {
    // 加载配置逻辑...
}

func getConfig(key string) string {
    once.Do(loadConfig) // 确保loadConfig只调用一次
    return config[key]
}

sync.Pool（对象池）

sync.Pool是一个可以存储和复用临时对象的池子，减少内存分配，提高效率。

var pool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer) // 创建新的Buffer实例
    },
}

func getBuffer() *bytes.Buffer {
    return pool.Get().(*bytes.Buffer) // 从池中获取Buffer
}

func putBuffer(buf *bytes.Buffer) {
    buf.Reset() // 清空Buffer
    pool.Put(buf) // 将Buffer放回池中
}

sync.Cond（条件变量）

sync.Cond用于等待或宣布事件的发生。通常与互斥锁结合使用。

var mu sync.Mutex
var cond = sync.NewCond(&mu)
var ready bool

func process() {
    mu.Lock()
    for !ready {
        cond.Wait() // 等待条件满足
    }
    // 处理...
    mu.Unlock()
}

func makeReady() {
    mu.Lock()
    ready = true
    cond.Broadcast() // 通知所有等待的协程
    mu.Unlock()
}

sync/atomic（原子操作）

sync/atomic包提供了底层的原子级内存操作，用于实现同步算法。

var count int32

func increment() {
    atomic.AddInt32(&count, 1) // 原子地增加计数
}

func getCount() int32 {
    return atomic.LoadInt32(&count) // 原子地读取计数
}

以上介绍了sync包中的一些基本组件，它们在并发编程中扮演着重要的角色。正确使用这些同步原语可以帮助我们编写出更加稳定、高效的并发程序。