Golang中的sync包是什么？如何使用？
参考回答
在 Go 语言中，sync 包提供了对并发操作的基本支持，包括锁、同步、并发安全的计数器等功能。它是实现并发编程的核心工具，能够有效地解决多个 goroutine 同时访问共享资源时的数据一致性问题。
常用的 sync 包功能包括：
1. 互斥锁（sync.Mutex）：用于保护共享资源，防止多个 goroutine 同时访问。
2. 读写锁（sync.RWMutex）：在读多写少的场景下优化性能。
3. 等待组（sync.WaitGroup）：用于等待一组 goroutine 完成。
4. 一次性操作（sync.Once）：确保初始化代码只执行一次。
5. 并发安全的 map（sync.Map）：一种线程安全的 map。
详细讲解与示例
1. sync.Mutex（互斥锁）
互斥锁确保同一时刻只有一个 goroutine 可以访问共享资源。
示例：
package main
import (
"fmt"
"sync"
)
var counter int
var mutex sync.Mutex
func increment(wg *sync.WaitGroup) {
defer wg.Done()
mutex.Lock() // 加锁
counter++
mutex.Unlock() // 解锁
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go increment(&wg)
}
wg.Wait()
fmt.Println("Final Counter:", counter) // 输出: Final Counter: 5
}
关键点：
– mutex.Lock() 和 mutex.Unlock() 必须成对使用。
– 如果忘记解锁，会导致死锁。
2. sync.RWMutex（读写锁）
sync.RWMutex提供了读锁（RLock）和写锁（Lock）。- 读锁允许多个 goroutine 同时读取，但写锁期间禁止所有读写。
示例：
package main
import (
"fmt"
"sync"
"time"
)
var rwMutex sync.RWMutex
var data int
func readData(id int, wg *sync.WaitGroup) {
defer wg.Done()
rwMutex.RLock() // 读锁
fmt.Printf("Goroutine %d reading data: %d\n", id, data)
time.Sleep(1 * time.Second)
rwMutex.RUnlock() // 释放读锁
}
func writeData(newValue int, wg *sync.WaitGroup) {
defer wg.Done()
rwMutex.Lock() // 写锁
fmt.Printf("Writing data: %d\n", newValue)
data = newValue
time.Sleep(1 * time.Second)
rwMutex.Unlock() // 释放写锁
}
func main() {
var wg sync.WaitGroup
wg.Add(1)
go writeData(42, &wg)
for i := 0; i < 3; i++ {
wg.Add(1)
go readData(i, &wg)
}
wg.Wait()
}
输出（写锁阻塞读操作）：
Writing data: 42
Goroutine 0 reading data: 42
Goroutine 1 reading data: 42
Goroutine 2 reading data: 42
3. sync.WaitGroup（等待组）
sync.WaitGroup 用于等待一组 goroutine 执行完成。
示例：
package main
import (
"fmt"
"sync"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // goroutine 结束时通知 WaitGroup
fmt.Printf("Worker %d starting\n", id)
// 模拟工作
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1) // 增加计数
go worker(i, &wg)
}
wg.Wait() // 等待所有 goroutine 完成
fmt.Println("All workers finished")
}
输出：
Worker 1 starting
Worker 2 starting
Worker 3 starting
Worker 1 done
Worker 2 done
Worker 3 done
All workers finished
4. sync.Once（一次性操作）
sync.Once 确保某段代码只执行一次（通常用于单例模式）。
示例：
package main
import (
"fmt"
"sync"
)
var once sync.Once
func initialize() {
fmt.Println("Initialized")
}
func main() {
for i := 0; i < 3; i++ {
go once.Do(initialize)
}
// 等待一会，确保 goroutine 执行完成
select {}
}
输出：
Initialized
无论 once.Do() 被调用多少次，initialize() 都只会执行一次。
5. sync.Map（并发安全的 map）
Go 提供了 sync.Map，用于高效、安全地在多个 goroutine 中操作共享的 map。
示例：
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
// 存储值
m.Store("name", "Alice")
m.Store("age", 25)
// 加载值
if value, ok := m.Load("name"); ok {
fmt.Println("Name:", value)
}
// 遍历
m.Range(func(key, value interface{}) bool {
fmt.Printf("%s: %v\n", key, value)
return true
})
}
输出：
Name: Alice
name: Alice
age: 25
总结
sync 包是 Go 并发编程的核心工具，提供了多种同步机制：
sync.Mutex：用于加锁和解锁，保护共享资源。sync.RWMutex：读写锁，适合读多写少的场景。sync.WaitGroup：用于等待一组 goroutine 完成。sync.Once：确保某段代码只执行一次。sync.Map：并发安全的 map，适合多 goroutine 并发读写。
这些工具可以根据具体需求组合使用，帮助开发者更安全、高效地处理并发场景。