当前位置：首页 > 文章列表 > Golang > Go教程 > Go语言sync包使用易错点：WaitGroup、Mutex、RWMutex解析

Go语言sync包使用易错点：WaitGroup、Mutex、RWMutex解析

2025-05-01 12:21:30 0浏览收藏

推广推荐

支持 PC / 移动端，安全直达

在Go语言中，sync包下的WaitGroup、Mutex和RWMutex是常用的并发管理工具，但使用不当易导致错误。WaitGroup易错点包括计数器误用和忘记调用Done；Mutex易错点主要是忘记Unlock和锁内panic未释放；RWMutex易错点在于读写锁混用可能导致死锁。通过理解这些工具的工作原理和最佳实践，可以显著提升代码的健壮性和性能。本文将详细探讨这些工具在实际使用中的易错场景，并分享项目中的经验教训。

在 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 管理一个共享的缓存。由于读操作远多于写操作，我们希望尽可能减少写锁对读操作的影响。然而，在某些情况下，频繁的写操作导致读操作被频繁阻塞，性能下降明显。最终，我们通过引入一个定时更新的策略来减少写锁的频率，从而显著提升了系统的整体性能。

在使用这些同步原语时，还有一些最佳实践值得注意：