Go语言中sync包提供Mutex、RWMutex、Once和WaitGroup实现并发安全：1. Mutex通过加锁保护共享变量避免竞态；2. RWMutex在读多写少场景提升性能，允许多个读锁共存；3. Once确保初始化操作仅执行一次；4. WaitGroup用于主线程等待所有goroutine完成任务。
在Go语言中，sync 包提供了多种原语来实现并发安全，尤其适用于多个goroutine访问共享资源的场景。虽然Go提倡“不要通过共享内存来通信，而是通过通信来共享内存”，但在实际开发中，仍不可避免地需要使用锁机制保护数据一致性。下面介绍如何使用 sync.Mutex、sync.RWMutex、sync.Once 和 sync.WaitGroup 实现常见的并发安全操作。
使用 sync.Mutex 保护共享变量
当多个goroutine同时读写同一个变量时，会出现竞态问题。使用 sync.Mutex 可以确保同一时间只有一个goroutine能访问临界区。
例如，实现一个并发安全的计数器：
type Counter struct {
mu sync.Mutex
value int
}
func (c *Counter) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.value++
}
func (c *Counter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value
}
每次修改或读取 value 前都加锁，避免数据竞争。可以使用 go run -race 来检测潜在的竞态条件。
立即学习“go语言免费学习笔记（深入）”；
使用 sync.RWMutex 提升读性能
如果结构体主要是读操作，偶尔写入，使用 sync.RWMutex 更高效。它允许多个读锁同时存在，但写锁独占。
改造上面的计数器：
type SafeCounter struct {
mu sync.RWMutex
value int
}
func (c *SafeCounter) Inc() {
c.mu.Lock()
defer c.mu.Unlock()
c.value++
}
func (c *SafeCounter) Value() int {
c.mu.RLock()
defer c.mu.RUnlock()
return c.value
}
读操作使用 RLock()，提升高并发读场景下的性能。
使用 sync.Once 确保初始化只执行一次
在并发环境下，某些初始化逻辑（如加载配置、创建单例）应只运行一次。sync.Once 能保证函数仅执行一次，无论多少goroutine调用。
var once sync.Once
var config map[string]string
func GetConfig() map[string]string {
once.Do(func() {
config = loadConfigFromDisk()
})
return config
}
即使多个goroutine同时调用 GetConfig()，loadConfigFromDisk() 也只会执行一次。
使用 sync.WaitGroup 等待一组goroutine完成
sync.WaitGroup 用于主线程等待所有子goroutine结束，常用于并发任务编排。
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", id)
}(i)
}
wg.Wait() // 阻塞直到所有goroutine调用 Done()
fmt.Println("All workers finished")
注意：应在 goroutine 外部调用 Add()，否则可能因调度问题导致 WaitGroup 计数不准确。
基本上就这些常见模式。合理使用 sync 包中的工具，可以在不依赖 channel 的情况下写出高效、安全的并发代码。关键是理解每种锁的适用场景，避免过度加锁影响性能，也要防止漏锁导致数据竞争。
