并发编程是 Go 语言的一大特色，而在 Go 语言的标准库中，sync 包提供了强大的功能来帮助我们高效、安全地处理并发任务。通过深入理解和合理利用这个包，我们可以编写出既简洁又高效的并发程序。今天，让我们一起探讨 sync 包中的六个关键概念，这些概念在日常的并发编程中都非常实用。
1. sync.Mutex 和 sync.RWMutex互斥锁 (Mutex) 是 Go 并发编程中的重要工具,它能确保 goroutine 不会同时访问共享资源。
sync.Mutex
看看这个简单的例子,我们没有使用互斥锁来保护变量 a:
var a = 0func Add() { a++}func main() { for i := 0; i < 500; i++ { go Add() } time.Sleep(5 * time.Second) fmt.Println(a)}这段代码的结果是不确定的,可能是 500,也可能小于 500。现在,让我们使用 sync.Mutex 来保护变量 a:
var mtx = sync.Mutex{}func Add() { mtx.Lock() defer mtx.Unlock() a++}现在,我们可以确保得到预期的结果。但是,如果我们使用 sync.RWMutex 会怎样呢?
sync.RWMutex
想象一下,你正在检查变量 a,但其他 goroutine 也在修改它。你可能会得到过时的信息。这时,sync.RWMutex 就派上用场了。
var mtx = sync.RWMutex{}func Add() { mtx.Lock() defer mtx.Unlock() a++}func Get() int { mtx.RLock() defer mtx.RUnlock() return a}sync.RWMutex 允许多个 goroutine 同时读取变量,同时确保只有一个 goroutine 可以写入。这对于读多写少的场景非常有用。
2. sync.WaitGroup使用 time.Sleep() 来等待所有 goroutine 完成并不是一个好办法。这时,sync.WaitGroup 就派上用场了:
func main() { wg := sync.WaitGroup{} for i := 0; i < 500; i++ { wg.Add(1) go func() { defer wg.Done() Add() }() } wg.Wait() fmt.Println(a)}sync.WaitGroup 有三个主要方法:Add、Done 和 Wait。
Add(delta int): 增加 WaitGroup 的计数器。通常在启动 goroutine 之前调用。Done(): 在 goroutine 完成任务时调用。Wait(): 阻塞调用者,直到 WaitGroup 的计数器归零。将 wg.Add(1) 和 defer wg.Done() 放在 go func() {} 内部是错误的,会引发竞争条件和运行时恐慌。
3. sync.Once有时在编程时,我们需要确保某些初始化操作只执行一次,即使它可能会在多个地方被调用或者由多个goroutine同时调用。举个例子,假设您在一个包中有一个 CreateInstance() 函数,在使用它之前需要先进行一些初始化工作。您可能会写出类似下面的实现:
var i = 0var _isInitialized = falsefunc CreateInstance() { if _isInitialized { return } i = GetISomewhere() _isInitialized = true}但是如果有多个goroutine同时调用这个方法会怎么样呢?即使您只希望初始化操作能够执行一次来保证程序的稳定性,i = GetISomeWhere 这行代码仍然会被多次调用。
您可以使用互斥锁来解决这个问题,但 Go 标准库中的 sync.Once 提供了一种更加便捷的方式:
var i = 0var once = &sync.Once{}func CreateInstance() { once.Do(func() { i = GetISomewhere() })}通过使用 sync.Once,您可以确保指定的初始化函数只会被执行一次,无论它被调用多少次或者同时有多少goroutine在调用它。这样不仅可以保证程序的正确性,还能提高性能。
4. sync.Poolsync.Pool 是一个存放复用对象的池子。它可以减轻垃圾回收器的压力,尤其是在创建和销毁资源的成本较高的情况下。
当需要一个对象时,可以直接从池中取出;使用完毕后,可以将其放回池中供后续重复利用。
var pool = sync.Pool{ New: func() interface{} { return 0 },}func main() { pool.Put(1) pool.Put(2) pool.Put(3) a := pool.Get().(int) b := pool.Get().(int) c := pool.Get().(int) fmt.Println(a, b, c) // 输出：1, 3, 2 (顺序可能有所不同)}需要注意的是,放入池中的对象的取出顺序并不一定与放入顺序一致。即使多次运行上述代码,取出顺序也可能不同。
使用sync.Pool的一些小贴士:
它非常适合于生命周期较长且需要管理多个实例的对象,如数据库连接、工作 goroutine 或缓冲区。在将对象放回池中之前,请务必重置其状态,以避免数据泄露或其他异常行为。不要过度依赖池中已有的对象,因为它们可能会被意外回收。5. sync.Map当需要并发地操作 map 时,使用带有 RWMutex 的普通 map 可能会遇到一些问题。并发的读写操作或写写操作可能会导致服务崩溃,而不是简单地覆盖数据或产生意外行为。
这就是 sync.Map 发挥作用的地方。它提供了一些有趣的方法:
CompareAndDelete(key, old any) - Go 1.20: 如果值匹配,则删除键的条目;如果不存在值或旧值为 nil,则返回 false。CompareAndSwap(key, old, new any) - Go 1.20: 如果它们匹配,就交换键的旧值和新值,请确保旧值是可比较的。Swap(key, value any) (previous any, loaded bool) - Go 1.20: 交换键的值并返回旧值(如果存在)。LoadOrStore(key, value any) (actual any, loaded bool): 获取当前键的值,或者如果它不存在则保存并返回提供的值。Range(f func(key, value any) bool): 遍历 map,对每对键值应用函数 f。如果 f 的返回值为 false,就停止遍历。Store, Delete, Load, LoadAndDelete为什么我们不直接使用带有 Mutex 的普通 map 呢?
在某些情况下,认识到 sync.Map 的优势是很重要的。当多个 goroutine 访问 map 中的不同键集时,单个互斥锁的普通 map 可能会引起争用,因为它会锁住整个 map 只为了一个写入操作。
另一方面,sync.Map 使用了一种更细粒度的锁定机制,有助于在这种场景中最小化争用。
6. sync.Condsync.Cond 可以看作是一个条件变量,它支持多个 goroutine 等待并相互通知。让我们看看如何使用它。
首先,我们需要用一个锁创建 sync.Cond:
var mtx sync.Mutexvar cond = sync.NewCond(&mtx)一个 goroutine 调用 cond.Wait() 并等待从其他地方发出的信号以继续执行:
func dummyGoroutine(id int) { cond.L.Lock() defer cond.L.Unlock() fmt.Printf("Goroutine %d正在等待...\n", id) cond.Wait() fmt.Printf("Goroutine %d接收到了信号。\n", id)}然后,另一个 goroutine (如主 goroutine) 调用 cond.Signal()或cond.Broadcast(),允许等待的 goroutine 继续执行:
func main() { go dummyGoroutine(1) go dummyGoroutine(2) time.Sleep(1 * time.Second) cond.Broadcast() // 向所有 goroutine 广播 time.Sleep(1 * time.Second)}结果如下:
Goroutine 1正在等待...Goroutine 2正在等待...Goroutine 2接收到了信号。Goroutine 1接收到了信号。为什么两个 goroutine 都能进入等待状态，尽管我们一开始就锁定了互斥锁?
这是因为 cond.Wait() 实际上会暂时释放内部的互斥锁(cond.L),允许其他 goroutine 获得锁并向前移动。
相比于使用通道,sync.Cond 的主要优势是它可以同时通知所有等待的 goroutine,而通道只能一次通知一个goroutine。sync.Cond 更适用于处理条件等待的场景,而通道更适用于goroutine之间的数据传递。
总结这六个概念共同构成了 Go 并发编程的强大基础，使 Go 成为处理高并发任务的理想选择。深入理解和正确应用这些工具，能够帮助我们构建出高效、健壮且稳定的并发应用，充分发挥 Go 语言的并发优势。总之，sync 包在 Go 并发编程中的重要性不言而喻，它不仅提高了代码的执行效率，也保障了程序的稳定性和安全性。
掌握Golang精髓，释放编程潜能！关注我的《Golang实用技巧》专栏，它将为你揭秘生产环境最佳实践，带你探索高并发编程的实用教程。从分享实用的Golang小技巧到深入剖析实际应用场景，让你成为真正的Golang大师。无论你是初学者还是经验丰富的开发者，这里都有你所需要的灵感和知识。让我们一同探索Golang的无限可能！
