---

一、简介

在 Golang 的并发编程中，sync 包提供了一些基本的同步原语，用于解决多个 Goroutine 之间的协调与资源共享问题。常用的工具包括：

• WaitGroup：用于等待一组 Goroutine 完成任务。
• Mutex：用于保护共享资源，避免多个 Goroutine 同时修改数据导致竞争条件（Race Condition）。

本篇博客将详细介绍 WaitGroup 和 Mutex 的用法，并通过示例帮助初学者理解它们在实际场景中的应用。

---

二、WaitGroup 的使用

1. 什么是 WaitGroup？

WaitGroup 是一个计数器，用于等待多个 Goroutine 完成任务。它可以让主 Goroutine 阻塞，直到所有子 Goroutine 完成工作。

2. 基本操作

• Add(delta int)：添加 delta 个 Goroutine 到计数器。
• Done()：每个 Goroutine 在完成任务后调用，减少计数器的值。
• Wait()：阻塞调用者，直到计数器变为 0。

3. WaitGroup 示例

package mainimport ("fmt""sync""time"
)func worker(id int, wg *sync.WaitGroup) {defer wg.Done() // 任务完成时调用 Donefmt.Printf("Worker %d starting...\n", id)time.Sleep(time.Second) // 模拟任务执行fmt.Printf("Worker %d done\n", id)
}func main() {var wg sync.WaitGroup // 创建 WaitGroup 实例for i := 1; i <= 3; i++ {wg.Add(1) // 每启动一个 Goroutine，计数器加 1go worker(i, &wg)}wg.Wait() // 等待所有 Goroutine 完成fmt.Println("All workers done!")
}

输出：

Worker 1 starting...
Worker 2 starting...
Worker 3 starting...
Worker 1 done
Worker 2 done
Worker 3 done
All workers done!

4. 注意事项

• 确保 Done 与 Add 匹配：每次 Add 对应一次 Done，否则可能会导致 Wait 永远阻塞。
• 并发调用 Add：如果需要在运行时动态启动 Goroutine，应确保 Add 操作发生在 Wait 之前。

---

三、Mutex 的使用

1. 什么是 Mutex？

Mutex（互斥锁）用于防止多个 Goroutine 同时访问共享资源，从而避免竞争条件。只有一个 Goroutine 能够在同一时间持有 Mutex，其它 Goroutine 必须等待。

2. 基本操作

• Lock()：获取锁。如果锁已被其他 Goroutine 持有，则阻塞。
• Unlock()：释放锁。

3. Mutex 示例

package mainimport ("fmt""sync""time"
)var (counter int          // 共享变量mutex   sync.Mutex   // 互斥锁保护共享变量
)func increment(id int, wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 5; i++ {mutex.Lock()   // 获取锁counter++      // 修改共享变量fmt.Printf("Goroutine %d incremented counter to %d\n", id, counter)mutex.Unlock() // 释放锁time.Sleep(time.Millisecond * 100) // 模拟其他操作}
}func main() {var wg sync.WaitGroupfor i := 1; i <= 3; i++ {wg.Add(1)go increment(i, &wg)}wg.Wait()fmt.Println("Final Counter Value:", counter)
}

输出（示例）：

Goroutine 1 incremented counter to 1
Goroutine 2 incremented counter to 2
Goroutine 3 incremented counter to 3
...
Final Counter Value: 15

---

四、竞争条件示例与解决

1. 竞争条件问题示例

如果不使用 Mutex，多个 Goroutine 同时修改共享变量时会产生不一致的数据。

package mainimport ("fmt""sync""time"
)var counter int // 共享变量func increment(wg *sync.WaitGroup) {defer wg.Done()for i := 0; i < 5; i++ {counter++time.Sleep(time.Millisecond * 100) // 模拟其他操作}
}func main() {var wg sync.WaitGroupfor i := 1; i <= 3; i++ {wg.Add(1)go increment(&wg)}wg.Wait()fmt.Println("Final Counter Value:", counter)
}

输出：

Final Counter Value: 12

由于多个 Goroutine 竞争访问 counter，导致最终值不正确。

---

2. 使用 Mutex 解决竞争条件

mutex.Lock()
counter++
mutex.Unlock()

通过为每次修改操作加锁，确保同一时间只有一个 Goroutine 可以修改 counter，从而避免数据不一致。

---

五、使用 RWMutex 实现读写锁

RWMutex 是一种读写锁，允许多个 Goroutine 同时读取，但在写入时需要独占锁。

RWMutex 示例

package mainimport ("fmt""sync""time"
)var (data  = 0rwMux sync.RWMutex
)func readData(id int, wg *sync.WaitGroup) {defer wg.Done()rwMux.RLock() // 获取读锁fmt.Printf("Goroutine %d reading data: %d\n", id, data)rwMux.RUnlock() // 释放读锁
}func writeData(wg *sync.WaitGroup) {defer wg.Done()rwMux.Lock() // 获取写锁data++fmt.Printf("Writing data: %d\n", data)rwMux.Unlock() // 释放写锁
}func main() {var wg sync.WaitGroupfor i := 1; i <= 3; i++ {wg.Add(1)go readData(i, &wg)}wg.Add(1)go writeData(&wg)wg.Wait()
}

---

六、小结

1. WaitGroup 用于等待一组 Goroutine 完成任务，是 Goroutine 同步的常用工具。
2. Mutex 和 RWMutex 用于保护共享资源，避免竞争条件。
3. 使用锁时需注意避免死锁和性能瓶颈。

---

在下一篇博客中，我们将介绍 Golang 的 Context 包，并探讨如何在并发操作中控制超时和取消任务。敬请期待！