Go语言Sync包
1、sync.Mutex和sync.RWMutex
在处理 goroutine 时,确保它们不会同时访问资源是非常重要的,而 mutex 可以帮助我们做到这一点。
1.1 sync.Mutex
看看这个简单的例子,我没有使用互斥锁来保护我们的变量 a:
package main
import (
"fmt"
"time"
)
var a = 0
func Add() {
a++
}
func main() {
for i := 0; i < 500; i++ {
go Add()
}
time.Sleep(2 * time.Second)
// 595
fmt.Println(a)
}
此代码的结果是不可预测的,如果幸运的话,您可能会得到 500,但通常结果会小于 500。现在,让我们使用互斥
增强我们的 Add 函数:
package main
import (
"fmt"
"sync"
"time"
)
var a = 0
var mtx = sync.Mutex{}
func Add() {
mtx.Lock()
defer mtx.Unlock()
a++
}
func main() {
for i := 0; i < 500; i++ {
go Add()
}
time.Sleep(2 * time.Second)
// 500
fmt.Println(a)
}
现在,代码提供了预期的结果。但是使用 sync.RWMutex 呢?
1.2 sync.RWMutex
想象一下,您正在检查 a 变量,但其他 goroutines 也在调整它。您可能会得到过时的信息。那么,解决这个问题
的方法是什么?
让我们退后一步,使用我们的旧方法,将 sync.Mutex 添加到我们的 Get() 函数中:
package main
import (
"fmt"
"sync"
"time"
)
var a = 0
var mtx = sync.Mutex{}
func Add() {
mtx.Lock()
defer mtx.Unlock()
a++
}
func Get() int {
mtx.Lock()
defer mtx.Unlock()
return a
}
func main() {
for i := 0; i < 500; i++ {
go Add()
}
for i := 0; i < 5; i++ {
fmt.Println(Get())
}
time.Sleep(2 * time.Second)
// 500
fmt.Println(a)
}
# 输出
491
500
500
500
500
500
但这里的问题是,如果您的服务或程序调用 Get() 数百万次而只调用 Add() 几次,那么我们实际上是在浪费资源,
因为我们大部分时间甚至都没有修改它而将所有内容都锁定了。
这就是 sync.RWMutex 突然出现来拯救我们的一天,这个聪明的小工具旨在帮助我们处理同时读取和写入的情
况。
package main
import (
"fmt"
"sync"
"time"
)
var a = 0
var mtx = sync.RWMutex{}
func Add() {
mtx.Lock()
defer mtx.Unlock()
a++
}
func Look() {
mtx.RLock()
defer mtx.RUnlock()
fmt.Println(a)
}
func main() {
for i := 0; i < 500; i++ {
go Add()
}
for i := 0; i < 5; i++ {
Look()
}
time.Sleep(2 * time.Second)
// 500
fmt.Println(a)
}
# 输出
480
481
482
483
484
500
那么,RWMutex 有什么了不起的呢?好吧,它允许数百万次并发读取,同时确保一次只能进行一次写入。让我澄
清一下它是如何工作的:
- 写入时,读取被锁定。
- 读取时,写入被锁定。
- 多次读取不会相互锁定。
2、sync.Locker
Mutex 和 RWMutex 都实现了 sync.Locker 接口{},签名是这样的:
// A Locker represents an object that can be locked and unlocked.
type Locker interface {
Lock()
Unlock()
}
如果你想创建一个接受 Locker 的函数,你可以将这个函数与你的自定义 locker 或同步互斥锁一起使用:
package main
import (
"fmt"
"sync"
"time"
)
var a = 0
var mtx = sync.Mutex{}
func Add(lock sync.Locker) {
lock.Lock()
defer lock.Unlock()
a++
}
func main() {
for i := 0; i < 500; i++ {
go Add(&mtx)
}
time.Sleep(2 * time.Second)
// 500
fmt.Println(a)
}
3、sync.WaitGroup
您可能已经注意到我使用了 time.Sleep(2 * time.Second) 来等待所有 goroutine 完成,但老实说,这是一个非常
丑陋的解决方案。
这就是 sync.WaitGroup 出现的地方:
package main
import (
"fmt"
"sync"
)
var a = 0
var mtx = sync.Mutex{}
func Add() {
mtx.Lock()
defer mtx.Unlock()
a++
}
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 有 3 个主要方法:Add、Done 和 Wait。
首先是 Add(delta int):此方法将 WaitGroup 计数器增加 delta 的值。你通常会在生成 goroutine 之前调用它,表
示有一个额外的任务需要完成。
其他两种方法非常简单:
- 当一个 goroutine 结束它的任务时, Done 被调用。
- Wait 会阻塞调用者,直到 WaitGroup 计数器归零,这意味着所有派生的 goroutine 都已完成它们的任务。
4、sync.Once
假设您在一个包中有一个 CreateInstance() 函数,但您需要确保它在使用前已初始化。所以你在不同的地方多次
调用它,你的实现看起来像这样:
var i = 0
var _isInitialized = false
func CreateInstance() {
if _isInitialized {
return
}
i = GetISomewhere()
_isInitialized = true
}
但是如果有多个 goroutine 调用这个方法呢? i = GetISomeWhere 行会运行多次,即使您为了稳定性只希望它执
行一次。
您可以使用我们之前讨论过的互斥锁,但同步包提供了一种更方便的方法:sync.Once
package main
import (
"math/rand"
"sync"
)
var i = 0
var once = &sync.Once{}
func CreateInstance() {
once.Do(func() {
i = GetISomewhere()
})
}
func GetISomewhere() int {
return rand.Int()
}
func main() {
CreateInstance()
}
使用 sync.Once,你可以确保一个函数只执行一次,不管它被调用了多少次或者有多少 goroutines 同时调用它。
5、sync.Pool
5.1 简单使用
想象一下,你有一个池,里面有一堆你想反复使用的对象。这可以减轻垃圾收集器的一些压力,尤其是在创建和销
毁这些资源的成本很高的情况下。
所以,无论何时你需要一个对象,你都可以从池中取出它。当您使用完它时,您可以将它放回池中以备日后重复使
用。
package main
import (
"fmt"
"sync"
)
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)
// 1 3 2
fmt.Println(a, b, c)
}
请记住,将对象放入池中的顺序不一定是它们出来的顺序,即使多次运行上述代码时顺序也是随机。
让我分享一些使用 sync.Pool 的技巧:
-
它非常适合长期存在并且有多个实例需要管理的对象,例如数据库连接(1000 个连接)、worker goroutine,
甚至缓冲区。
-
在将对象返回池之前始终重置对象的状态。这样,您可以避免任何无意的数据泄漏或奇怪的行为。
-
不要指望池中已经存在的对象,因为它们可能会意外释放。
5.2 介绍
在 Golang 中,sync.Pool 是一个非常有用的工具。它是用于存储和重用临时对象的池。在高并发的情况下,
sync.Pool 可以显著提高程序的性能,减少内存分配和垃圾回收的压力。本文将详细介绍 sync.Pool 的使用方法和
注意事项,希望能对广大 Golang 程序员有所帮助。
5.3 基本用法
sync.Pool 的基本用法非常简单。我们只需要创建一个 sync.Pool 对象,然后在需要使用临时对象的时候,从池中
取出对象即可。如果池中没有可用的对象,那么 Pool.Get() 方法会返回 nil。当我们用完对象之后,需要将其放回
池中,以便下次使用。
package main
import (
"fmt"
"sync"
)
func main() {
pool := &sync.Pool{
New: func() interface{} {
return "Hello, World!"
},
}
// 从池中取出对象
obj := pool.Get()
// 输出:Hello, World!
fmt.Println(obj)
// 将对象放回池中
pool.Put(obj)
// 再次从池中取出对象
obj = pool.Get()
// 输出:Hello, World!
fmt.Println(obj)
}
# 输出
Hello, World!
Hello, World!
在上面的示例中,我们创建了一个池,池中存储的是字符串 “Hello, World!”。我们首先从池中取出对象,然后将
其放回池中,最后再次取出对象。由于我们只创建了一个对象,所以两次输出的结果都是相同的。
5.4 高级用法
除了上面的基本用法之外,sync.Pool 还有一些高级用法,可以让我们更好地掌控池中对象的生命周期。下面我们
来逐一介绍这些用法。
5.4.1 生命周期
sync.Pool 中存储的对象并不会一直存在,它们的生命周期是由垃圾回收器控制的。如果一个对象在一定时间内没
有被使用,那么它就会被垃圾回收器回收。这个时间是不确定的,它取决于垃圾回收器的具体实现。
因此,我们不能依赖 sync.Pool 中的对象一直存在,必须在每次使用之前都检查对象是否为空。如果对象为空,那
么我们需要重新创建一个对象并放入池中。
5.4.2 GC 问题
由于 sync.Pool 中的对象是由垃圾回收器控制的,因此在使用 sync.Pool 时,需要注意避免对象被过早地回收。如
果我们在使用对象时没有及时将其放回池中,那么垃圾回收器可能会将对象回收,从而导致程序出现问题。
为了避免这种情况的发生,我们可以使用 sync.Pool 的 Finalizer 方法。Finalizer 方法可以在对象被回收之前执行
一些清理操作,从而保证对象在被回收之前能够被正确地处理。
下面是一个示例:
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
type Foo struct {
Name string
}
func (f *Foo) Close() {
fmt.Printf("Closing Foo %s\n", f.Name)
}
func main() {
pool := &sync.Pool{
New: func() interface{} {
return &Foo{Name: "Bar"}
},
}
// 从池中取出对象
obj := pool.Get().(*Foo)
fmt.Println(obj.Name) // 输出:Bar
// 将对象放回池中
pool.Put(obj)
// 等待 1 秒钟
time.Sleep(time.Second)
// 再次从池中取出对象
obj = pool.Get().(*Foo)
fmt.Println(obj.Name) // 输出:Bar
// 使用 Finalizer 方法
runtime.SetFinalizer(obj, func(f *Foo) {
f.Close()
})
// 等待 1 秒钟
time.Sleep(time.Second)
}
# 输出
Bar
Bar
在上面的示例中,我们创建了一个 Foo 对象,并将其放入 sync.Pool 中。我们在使用对象之前,等待了 1 秒钟,
从而模拟对象被长时间占用的情况。然后我们再次从池中取出对象,并使用 Finalizer 方法为其设置一个回收方
法。该回收方法会在对象被回收之前执行,从而保证对象能够被正确地处理。
5.4.3 并发安全性
sync.Pool 对象本身是并发安全的。多个 goroutine 可以同时访问同一个 sync.Pool 对象,并且不需要额外的锁来
保证并发安全性。这是因为 sync.Pool 内部使用了 sync.Mutex 来保证并发安全性。
但是,需要注意的是,由于 sync.Pool 中存储的对象是共享的,因此我们需要在使用对象时进行一些额外的同步操
作,以避免出现竞态条件。例如,如果我们从池中取出一个对象,然后对其进行修改,那么其他 goroutine 可能
会同时访问到同一个对象,从而导致数据竞争。
下面是一个示例:
package main
import (
"fmt"
"sync"
)
type Counter struct {
mu sync.Mutex
count int
}
func (c *Counter) Add(n int) {
c.mu.Lock()
defer c.mu.Unlock()
c.count += n
}
func (c *Counter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.count
}
func main() {
pool := &sync.Pool{
New: func() interface{} {
return &Counter{}
},
}
// 从池中取出对象
counter := pool.Get().(*Counter)
// 对对象进行修改
counter.Add(1)
// 将对象放回池中
pool.Put(counter)
// 再次从池中取出对象
counter = pool.Get().(*Counter)
// 对对象进行修改
counter.Add(1)
// 输出对象的值
fmt.Println(counter.Value()) // 输出:2
}
# 输出
2
在上面的示例中,我们创建了一个 Counter 对象,并将其放入 sync.Pool 中。我们首先从池中取出对象,并对其
进行修改。然后将对象放回池中,再次取出对象,并对其进行修改。最后输出对象的值。由于我们对同一个对象进
行了两次修改,因此输出的结果是 2。
6、sync.Map
当您同时使用 map 时,有点像使用 RWMutex。您可以同时进行多次读取,但不能进行多次读写或写入。如果存
在冲突,您的服务将崩溃而不是覆盖数据或导致意外行为。
这就是 sync.Map 派上用场的地方,因为它可以帮助我们避免这个问题。让我们仔细看看 sync.Map 给我们提供什
么:
- CompareAndDelete (go 1.20):如果值匹配则删除键的条目;如果不存在值或旧值为 nil,则返回 false。
- CompareAndSwap(go 1.20):如果新旧值匹配,则交换一个键,只要确保旧值是可比较的。
- Swap (go 1.20):交换键的值并返回旧值(如果存在)。
- LoadOrStore:获取当前键值或保存并返回提供的值(如果不存在)
- Range (f func(key, value any):遍历映射,将函数 f 应用于每个键值对。如果 f 说返回 false,它会停止。
- Store
- Delete
- Load
- LoadAndDelete
我们为什么不使用带有 Mutex 的常规 map 呢?
我通常选择带有 RWMutex 的 map,但在某些情况下认识到 sync.Map 的强大功能很重要。那么,它真正发光的
地方在哪里呢?
如果您有许多 goroutines 访问 map 中的单独键,则具有单个互斥锁的常规 map 可能会导致争用,因为它仅针对
单个写操作锁定整个 map。
另一方面,sync.Map 使用更完善的锁定机制,有助于最大限度地减少此类场景中的争用。
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
// 1. 写入
m.Store("aa", 18)
m.Store("bb", 20)
// 2. 读取
age, _ := m.Load("aa")
fmt.Println(age.(int))
// 3. 遍历
m.Range(func(key, value interface{}) bool {
name := key.(string)
age := value.(int)
fmt.Println(name, age)
return true
})
// 4. 删除
m.Delete("aa")
age, ok := m.Load("aa")
fmt.Println(age, ok)
// 5. 读取或写入
// 这个key已经存在,因此写入不成功,并且读出原值
m.LoadOrStore("bb", 100)
age, _ = m.Load("bb")
fmt.Println(age)
}
# 程序输出
18
aa 18
bb 20
<nil> false
20
7、sync.Cond
在并发编程中,条件变量是一种常用的线程间协作机制,它可以让一个或多个线程等待某个条件的满足,从而实现
线程间的同步和通信。在 Go 语言中,sync 包提供了 Cond 类型来支持条件变量的使用。
sync.Cond 是基于互斥锁/读写锁实现的条件变量,用来协调想要访问共享资源的那些 Goroutine。当共享资源状
态发生变化时,sync.Cond 可以用来通知等待条件发生而阻塞的 Goroutine。
sync.Cond 基于互斥锁/读写锁,那它和互斥锁有什么区别呢?
互斥锁 sync.Mutex 通常用来保护共享的临界资源,条件变量 sync.Cond 用来协调想要访问共享资源的
Goroutine。当共享资源的状态发生变化时,sync.Cond 可以用来通知被阻塞的 Goroutine。
下面将深入探讨 sync.Cond 的使用方法和注意事项,帮助你更好地理解 Go 语言中的并发编程。
7.1 简单案例
将 sync.Cond 视为支持多个 goroutine 等待和相互交互的条件变量。为了更好地理解,让我们看看如何使用它。
首先,我们需要创建带有 Locker 的 sync.Cond:
var mtx sync.Mutex
var cond = sync.NewCond(&mtx)
goroutine 调用 cond.Wait 并等待来自其他地方的信号以继续执行:
func dummyGoroutine(id int) {
cond.L.Lock()
defer cond.L.Unlock()
fmt.Printf("Goroutine %d is waiting...\n", id)
cond.Wait()
fmt.Printf("Goroutine %d received the signal.\n", id)
}
然后,另一个 goroutine(就像主 goroutine)调用 cond.Signal(),让我们等待的 goroutine 继续:
func main() {
go dummyGoroutine(1)
time.Sleep(1 * time.Second)
fmt.Println("Sending signal...")
cond.Signal()
time.Sleep(1 * time.Second)
}
总代码:
package main
import (
"fmt"
"sync"
"time"
)
var mtx sync.Mutex
var cond = sync.NewCond(&mtx)
func dummyGoroutine(id int) {
cond.L.Lock()
defer cond.L.Unlock()
fmt.Printf("Goroutine %d is waiting...\n", id)
cond.Wait()
fmt.Printf("Goroutine %d received the signal.\n", id)
}
func main() {
go dummyGoroutine(1)
time.Sleep(1 * time.Second)
fmt.Println("Sending signal...")
cond.Signal()
time.Sleep(1 * time.Second)
}
结果如下所示:
# 输出
Goroutine 1 is waiting...
Sending signal...
Goroutine 1 received the signal.
如果有多个 goroutines 在等待我们的信号怎么办? 这就是我们可以使用广播的时候:
package main
import (
"fmt"
"sync"
"time"
)
var mtx sync.Mutex
var cond = sync.NewCond(&mtx)
func dummyGoroutine(id int) {
cond.L.Lock()
defer cond.L.Unlock()
fmt.Printf("Goroutine %d is waiting...\n", id)
cond.Wait()
fmt.Printf("Goroutine %d received the signal.\n", id)
}
func main() {
go dummyGoroutine(1)
go dummyGoroutine(2)
time.Sleep(1 * time.Second)
// broadcast to all goroutines
cond.Broadcast()
time.Sleep(1 * time.Second)
}
结果如下所示:
# 输出
Goroutine 1 is waiting...
Goroutine 2 is waiting...
Goroutine 2 received the signal.
Goroutine 1 received the signal.
7.2 实现原理
条件变量的实现原理基于互斥锁和 goroutine 队列。
假设有一个条件变量 cond,初始时它没有被触发。当一个 goroutine 调用 cond.Wait() 方法时,它会加锁并将自
己加入到 cond 的 goroutine 队列中。接着,它会解锁并进入睡眠状态,等待被唤醒。
当另一个 goroutine 调用 cond.Signal() 或者 cond.Broadcast() 方法时,它会重新加锁,并从 cond 的 goroutine
队列中选择一个 goroutine 唤醒。被唤醒的 goroutine 会重新加锁,然后继续执行。
需要注意的是,被唤醒的 goroutine 并不会立即执行,它会等待重新获得锁之后才会继续执行。
7.3 Cond 类型
Cond 类型是 Go 语言中的条件变量类型,它的定义如下:
type Cond struct {
// contains filtered or unexported fields
}
Cond 类型包含了一些私有字段,我们无法直接访问它们。但是,sync 包提供了一些方法来操作 Cond 类型的实
例。
7.4 NewCond创建实例
sync.Cond 对象需要依赖一个 sync.Mutex 或 sync.RWMutex 对象来进行同步和互斥操作。我们可以使用
sync.NewCond 方法来创建一个新的 sync.Cond 对象,该方法接受一个 Mutex 或 RWMutex 对象作为参数,返回
一个对应的条件变量对象。
func NewCond(l Locker) *Cond
7.5 Wait 方法
sync.Cond 提供了 Wait 方法来等待条件变量的信号。Wait 方法需要在持有 Mutex 或 RWMutex 的情况下进行调
用,否则会抛出 panic 异常。
Wait 方法是 Cond 类型的核心方法之一,它用于等待条件变量的满足。Wait 方法的定义如下:
func (c *Cond) Wait()
Wait 方法将当前 goroutine 暂停,等待条件变量的信号。在等待过程中,Mutex 或 RWMutex 将被释放,其他
goroutine 可以获取锁并修改共享变量,但是当前 goroutine 仍然保持在等待队列中,直到收到唤醒信号。当
Wait 方法返回时,Mutex 或 RWMutex 会自动重新被锁定。
Wait 方法会阻塞当前的 goroutine,直到条件变量满足。在调用 Wait 方法之前,我们需要先获取锁,以确保条件
变量的正确使用。例如:
package main
import (
"fmt"
"sync"
"time"
)
var mu sync.Mutex
var cond = sync.NewCond(&mu)
func main() {
go func() {
time.Sleep(time.Second)
mu.Lock()
cond.Signal()
mu.Unlock()
}()
mu.Lock()
cond.Wait()
fmt.Println("condition satisfied")
mu.Unlock()
}
# 输出
condition satisfied
在上面的例子中,我们创建了一个 Mutex 类型的实例 mu 和一个 Cond 类型的实例 cond。在主 goroutine 中,
我们先获取了锁 mu,然后调用 cond.Wait() 方法等待条件变量的满足。在另一个 goroutine 中,我们等待 1 秒钟
后获取了锁 mu,然后调用 cond.Signal() 方法向等待的 goroutine 发送信号,表示条件变量已经满足。最后,我
们释放锁 mu。
需要注意的是,Wait 方法会自动释放锁,以便其他 goroutine 可以获取锁并修改条件变量。当 Wait 方法返回时,
它会重新获取锁,以便继续执行后续的代码。
7.6 Signal 唤醒一个协程
Signal 方法用于唤醒等待队列中的一个 goroutine,使其继续执行。在调用 Signal 方法之前,必须先获得 Mutex
或 RWMutex 的锁。
Signal 方法用于向等待的 goroutine 发送信号,表示条件变量已经满足。其定义如下:
func (c *Cond) Signal()
Signal 方法会选择一个等待的 goroutine 并唤醒它。如果没有等待的 goroutine,Signal 方法不会做任何事情。
7.7 Broadcast 广播唤醒所有
Broadcast 方法用于唤醒等待队列中的所有 goroutine,使它们继续执行。在调用 Broadcast 方法之前,必须先获
得 Mutex 或 RWMutex 的锁。
Broadcast 方法用于向所有等待的 goroutine 发送信号,表示条件变量已经满足。其定义如下:
func (c *Cond) Broadcast()
Broadcast 方法会唤醒所有等待的 goroutine。如果没有等待的 goroutine,Broadcast 方法不会做任何事情。
需要注意的是,Signal 和 Broadcast 方法只有在获取锁之后才能调用。否则,会导致 panic。
7.8 示例1
下面是一个使用 Cond 类型实现生产者-消费者模型的示例:
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
type Queue struct {
items []int
cond *sync.Cond
}
func NewQueue() *Queue {
q := &Queue{cond: sync.NewCond(&sync.Mutex{})}
go func() {
for {
time.Sleep(time.Second)
q.cond.L.Lock()
q.items = append(q.items, rand.Intn(100))
q.cond.Signal()
q.cond.L.Unlock()
}
}()
return q
}
func (q *Queue) Get() int {
q.cond.L.Lock()
for len(q.items) == 0 {
q.cond.Wait()
}
item := q.items[0]
q.items = q.items[1:]
q.cond.L.Unlock()
return item
}
func main() {
q := NewQueue()
for i := 0; i < 10; i++ {
fmt.Println(q.Get())
}
}
# 输出
81
87
47
59
81
18
25
40
56
0
在上面的例子中,我们定义了一个 Queue 类型,它包含一个 int 类型的切片 items 和一个 Cond 类型的实例
cond。在 NewQueue 函数中,我们启动了一个 goroutine,每秒钟向 items 中添加一个随机数,并调用
cond.Signal() 方法通知等待的 goroutine。在 Get 方法中,我们使用 cond.Wait() 方法等待 items 不为空,并返回
第一个元素。
7.9 示例2
package main
import (
"log"
"sync"
"time"
)
var done = false
func read(name string, c *sync.Cond) {
c.L.Lock()
for !done {
c.Wait()
}
log.Println(name, "starts reading")
c.L.Unlock()
}
func write(name string, c *sync.Cond) {
log.Println(name, "starts writing")
time.Sleep(time.Second)
c.L.Lock()
done = true
c.L.Unlock()
log.Println(name, "wakes all")
c.Broadcast()
}
func main() {
cond := sync.NewCond(&sync.Mutex{})
go read("reader1", cond)
go read("reader2", cond)
go read("reader3", cond)
write("writer", cond)
time.Sleep(time.Second * 3)
}
# 输出
2023/07/03 16:02:08 writer starts writing
2023/07/03 16:02:09 writer wakes all
2023/07/03 16:02:09 reader3 starts reading
2023/07/03 16:02:09 reader1 starts reading
2023/07/03 16:02:09 reader2 starts reading
-
done 即互斥锁需要保护的条件变量。
-
read() 调用 Wait() 等待通知,直到 done 为 true。
-
write() 接收数据,接收完成后,将 done 置为 true,调用 Broadcast() 通知所有等待的协程。
-
write() 中的暂停了 1s,一方面是模拟耗时,另一方面是确保前面的 3 个 read 协程都执行到 Wait(),处于等
待状态。main 函数最后暂停了 3s,确保所有操作执行完毕。
7.10 注意事项
在使用 Cond 类型时,需要注意以下几点:
-
在调用 Wait 方法之前,必须先获取锁。否则,会导致 panic。
-
Wait 方法会自动释放锁,以便其他 goroutine 可以获取锁并修改条件变量。当 Wait 方法返回时,它会重新获
取锁,以便继续执行后续的代码。
-
Signal 和 Broadcast 方法只有在获取锁之后才能调用。否则,会导致 panic。
-
Signal 方法会选择一个等待的 goroutine 并唤醒它。如果没有等待的 goroutine,Signal 方法不会做任何事
情。
-
Broadcast 方法会唤醒所有等待的 goroutine。如果没有等待的 goroutine,Broadcast 方法不会做任何事
情。
-
在使用 sync.Cond 前,一定要先创建一个互斥锁。
-
在调用 Wait 方法前,一定要先获取互斥锁,否则会导致死锁。
-
在调用 Wait 方法后,当前 goroutine 会被阻塞,直到被唤醒。
-
在调用 Signal 或 Broadcast 方法后,等待队列中的一个或多个 goroutine 会被唤醒,但不会立即获取互斥
锁。因此,在使用 Signal 或 Broadcast 方法时,一定要保证唤醒的 goroutine 不会互相竞争同一个资源。
-
在调用 Signal 或 Broadcast 方法后,一定要释放互斥锁,否则被唤醒的 goroutine 无法获取到互斥锁,仍然
会被阻塞。
-
在使用 sync.Cond 时,一定要注意竞争条件和数据同步的问题,确保程序的正确性和稳定性。
7.11 结语
在上面我们深入探讨了 sync.Cond 类型的使用方法和注意事项。我们学习了 Wait、Signal 和 Broadcast 方法的使
用,并通过一个生产者-消费者模型的示例来演示了 Cond 类型的实际应用。希望本文能够帮助你更好地理解 Go文章来源:https://www.toymoban.com/news/detail-591169.html
语言中的并发编程。文章来源地址https://www.toymoban.com/news/detail-591169.html
到了这里,关于Go语言Sync包的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!