在 go 语言中，sync 包下的 waitgroup、mutex 和 rwmutex 使用不当易导致错误。1. waitgroup 易错场景：计数器误用和忘记调用 done。2. mutex 易错场景：忘记 unlock 和锁内 panic 未释放。3. rwmutex 易错场景：读写锁混用导致死锁。通过理解这些工具的工作原理和最佳实践，可以提升代码的健壮性和性能。
探讨 Go 语言中 sync 包下 WaitGroup、Mutex、RWMutex 等在实际使用中的易错场景
在 Go 语言中，sync 包提供了多种并发原语，用于管理并发任务和同步操作。其中，WaitGroup、Mutex 和 RWMutex 是开发者常用的工具。它们虽然功能强大，但如果使用不当，容易导致一些难以排查的错误。今天我们就来探讨一下这些工具在实际使用中的易错场景，并分享一些我在项目中遇到的经验教训。
首先，来说说 WaitGroup。WaitGroup 用于等待一组 goroutine 完成。它通过 Add、Done 和 Wait 方法来管理计数器。如果使用不当，最常见的问题就是计数器的误用。
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", id)
}
<p>func main() {
var wg sync.WaitGroup</p><pre class='brush:php;toolbar:false;'>for i := 1; i <= 5; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Println("All workers completed")}
在上面的代码中，wg.Add(1) 必须在 go worker(i, &wg) 之前调用。如果顺序颠倒，可能会导致 WaitGroup 的计数器在 goroutine 启动前就已经减少为零，导致 Wait 立即返回，程序逻辑出错。
另一个常见问题是忘记调用 wg.Done()。如果在 worker 函数中没有使用 defer wg.Done()，可能会导致 WaitGroup 永远等待下去，因为计数器不会减少到零。
再来看 Mutex，它用于互斥锁，确保同一时间只有一个 goroutine 可以访问共享资源。使用 Mutex 的易错场景主要集中在锁的获取和释放上。
var (
mu sync.Mutex
count int
)
<p>func increment() {
mu.Lock()
count++
mu.Unlock()
}</p><p>func main() {
for i := 0; i < 1000; i++ {
go increment()
}
time.Sleep(time.Second)
fmt.Println("Count:", count)
}</p>在上面的代码中，如果忘记调用 mu.Unlock()，会导致死锁，因为其他 goroutine 无法获取锁。更隐蔽的问题是，如果在锁内发生 panic，锁不会被自动释放。这时可以使用 defer 来确保锁被释放：
func increment() {
mu.Lock()
defer mu.Unlock()
count++
}
使用 defer 可以确保无论函数是否正常返回，锁都会被释放，避免死锁的发生。
最后，RWMutex 用于读写锁，它允许多个 goroutine 同时读取共享资源，但写操作是互斥的。使用 RWMutex 的易错场景主要在于读写锁的混用。
var (
rwMu sync.RWMutex
value int
)
<p>func read() int {
rwMu.RLock()
defer rwMu.RUnlock()
return value
}</p><p>func write(newValue int) {
rwMu.Lock()
defer rwMu.Unlock()
value = newValue
}</p><p>func main() {
go func() {
for {
write(rand.Intn(100))
time.Sleep(time.Millisecond * 100)
}
}()</p><pre class='brush:php;toolbar:false;'>for i := 0; i < 10; i++ {
fmt.Println("Read:", read())
time.Sleep(time.Second)
}}
在使用 RWMutex 时，如果在读锁期间尝试获取写锁，会导致死锁，因为读锁不会释放直到所有读操作完成。因此，确保在读锁和写锁之间没有死锁是非常重要的。
在实际项目中，我曾遇到过一个有趣的案例：在一个高并发的系统中，使用 RWMutex 管理一个共享的缓存。由于读操作远多于写操作，我们希望尽可能减少写锁对读操作的影响。然而，在某些情况下，频繁的写操作导致读操作被频繁阻塞，性能下降明显。最终，我们通过引入一个定时更新的策略来减少写锁的频率，从而显著提升了系统的整体性能。
在使用这些同步原语时，还有一些最佳实践值得注意：
- 尽量减少锁的粒度，避免长时间持有锁。
- 使用 defer 来确保锁的释放，特别是在可能发生 panic 的情况下。
- 在使用 WaitGroup 时，确保 Add 和 Done 的调用顺序正确。
- 对于 RWMutex，尽量减少写操作的频率，避免对读操作的阻塞。
总的来说，sync 包中的这些工具在并发编程中非常重要，但使用时需要谨慎，避免常见的错误。通过理解这些工具的工作原理和易错场景，我们可以在实际项目中更好地管理并发，提升代码的健壮性和性能。
