深入理解Go语言中的sync.Cond

1. 简介

本文将介绍 Go 语言中的 sync.Cond 并发原语，包括 sync.Cond的基本使用方法、实现原理、使用注意事项以及常见的使用使用场景。能够更好地理解和应用 Cond 来实现 goroutine 之间的同步。
2. 基本使用

2.1 定义

sync.Cond是Go语言标准库中的一个类型，代表条件变量。条件变量是用于多个goroutine之间进行同步和互斥的一种机制。sync.Cond可以用于等待和通知goroutine，以便它们可以在特定条件下等待或继续执行。
2.2 方法说明

sync.Cond的定义如下，提供了Wait ,Singal,Broadcast以及NewCond方法

1. type Cond struct {
2.    noCopy noCopy
3.    // L is held while observing or changing the condition
4.    L Locker
6.    notify  notifyList
7.    checker copyChecker
8. }
10. func NewCond(l Locker) *Cond {}
11. func (c *Cond) Wait() {}
12. func (c *Cond) Signal() {}
13. func (c *Cond) Broadcast() {}

复制代码

• NewCond方法： 提供创建Cond实例的方法
  
• Wait方法: 使当前线程进入阻塞状态，等待其他协程唤醒
  
• Singal方法: 唤醒一个等待该条件变量的线程，如果没有线程在等待，则该方法会立即返回。
  
• Broadcast方法: 唤醒所有等待该条件变量的线程，如果没有线程在等待，则该方法会立即返回。
  

2.3 使用方式

当使用sync.Cond时，通常需要以下几个步骤：

• 定义一个互斥锁，用于保护共享数据；
  
• 创建一个sync.Cond对象，关联这个互斥锁；
  
• 在需要等待条件变量的地方，获取这个互斥锁，并使用Wait方法等待条件变量被通知；
  
• 在需要通知等待的协程时，使用Signal或Broadcast方法通知等待的协程。
  
• 最后，释放这个互斥锁。
  

下面是一个简单的代码的示例，展示了大概的代码结构:

1. var (
2.     // 1. 定义一个互斥锁
3.     mu    sync.Mutex
4.     cond  *sync.Cond
5.     count int
6. )
7. func init() {
8.     // 2.将互斥锁和sync.Cond进行关联
9.     cond = sync.NewCond(&mu)
10. }
11. go func(){
12.     // 3. 在需要等待的地方,获取互斥锁，调用Wait方法等待被通知
13.     mu.Lock()
14.     // 这里会不断循环判断 是否满足条件
15.     for !condition() {
16.        cond.Wait() // 等待任务
17.     }
18.     mu.Unlock()
19. }
21. go func(){
22.      // 执行业务逻辑
23.      // 4. 满足条件，此时调用Broadcast唤醒处于等待状态的协程
24.      cond.Broadcast()
25. }

复制代码

2.4 使用例子

下面通过描述net/http中的 connReader，来展示使用sync.Cond实现阻塞等待通知的机制。这里我们不需要理解太多，只需要知道connReader下面两个方法:

1. func (cr *connReader) Read(p []byte) (n int, err error) {}
2. func (cr *connReader) abortPendingRead() {}

复制代码

Read方法则是用于从HTTP连接中读取数据，不允许并发访问的。而abortPendingRead则是用于终止正在读取的连接。
从abortPendingRead方法的语意来看，是需要成功终止其他协程进行数据的读取之后，才能正常返回，也就是此时没有协程再继续读取数据了，才可以返回。
那abortPendingRead如何得知是否还有协程在读取数据呢，其实是可以通过定时轮训connReader的状态，从而判断当前Read方法是否仍在读取数据。但是定时轮训效率太低，可能会造成cpu的大量空转。更好的方式，应该是让协程进入阻塞状态，然后等条件满足了，其他协程再来唤醒当前协程，然后再继续运行下去。
这个其实就是sync.Cond设计的用途，当不满足运行条件时，先进入阻塞状态，等待条件满足时，再由其他协程来唤醒，然后再继续运行下去，能够提高程序的执行效率。其中Wait方法便是让协程进入阻塞状态，而Singal和Boardcast便是唤醒处于阻塞状态的协程，告知其条件满足了，可以继续向下执行了。
回到我们connReader的例子，我们使用sync.Cond实现阻塞等待通知的效果。

1. type connReader struct {
2.     // 是否正在读取数据
3.     inRead bool
4.     mu      sync.Mutex // guards following
5.     cond    *sync.Cond
6. }
8. func (cr *connReader) abortPendingRead() {
9.     if !cr.inRead{
10.         return
11.     }
12.     //1. 通过一定手段,让Read方法中断
13.     cr.mu.Lock()
14.     // 判断Read方法是否仍然在读取数据
15.     for cr.inRead {
16.         //2. 此时Read方法仍然在读取数据, 不满足条件，等待通知
17.         cr.cond.Wait()
18.     }
19.     cr.mu.Unlock()
20. }
22. func (cr *connReader) Read(p []byte) (n int, err error) {
23.      cr.mu.Lock()
24.      cr.inRead = true
25.     // 1. 读取数据
26.     // 2. abortPendingRead通过某种手段,让Read方法中断
27.    
28.     cr.inRead = false
29.     cr.mu.Unlock()
30.     // 3. 现在已经满足abortPendingRead继续执行下去的条件了，可以唤醒abortPendingRead协程了
31.     cond.Boardcast()
32. }

复制代码

这里abortPendingRead方法首先判断是否还在读取数据，是的话，调用Wait方法进入阻塞状态，等待条件满足后继续执行。
对于Read方法，因为其不运行并发访问，当其将退出时，说明此时已经没有协程在读取数据了，满足abortPendingRead继续执行下去的条件了，此时可以调用Boardcast来唤醒等待条件满足的协程。之后调用abortPendingRead方法的协程此时能够接收到通知，便能够顺利被唤醒，从而正确返回。
这里便展示了一个简单的，使用sync.Cond实现阻塞等待通知的例子。
3. 原理

3.1 基本原理

在Sync.Cond存在一个通知队列，保存了所有处于等待状态的协程。通知队列定义如下:

1. type notifyList struct {
2.    wait   uint32
3.    notify uint32
4.    lock   uintptr // key field of the mutex
5.    head   unsafe.Pointer
6.    tail   unsafe.Pointer
7. }

复制代码

当调用Wait方法时，此时Wait方法会释放所持有的锁，然后将自己放到notifyList等待队列中等待。此时会将当前协程加入到等待队列的尾部，然后进入阻塞状态。
当调用Signal 时，此时会唤醒等待队列中的第一个协程，其他继续等待。如果此时没有处于等待状态的协程，调用Signal不会有其他作用，直接返回。当调用BoradCast方法时，则会唤醒notfiyList中所有处于等待状态的协程。
sync.Cond的代码实现比较简单，协程的唤醒和阻塞已经由运行时包实现了，sync.Cond的实现直接调用了运行时包提供的API。
3.2 实现

3.2.1 Wait方法实现

Wait方法首先调用runtime_notifyListAd方法，将自己加入到等待队列中，然后释放锁，等待其他协程的唤醒。

1. func (c *Cond) Wait() {
2.    // 将自己放到等待队列中
3.    t := runtime_notifyListAdd(&c.notify)
4.    // 释放锁
5.    c.L.Unlock()
6.    // 等待唤醒
7.    runtime_notifyListWait(&c.notify, t)
8.    // 重新获取锁
9.    c.L.Lock()
10. }

复制代码

3.2.2 Singal方法实现

Singal方法调用runtime_notifyListNotifyOne唤醒等待队列中的一个协程。

1. func (c *Cond) Signal() {
2.    // 唤醒等待队列中的一个协程
3.    runtime_notifyListNotifyOne(&c.notify)
4. }

复制代码

3.2.3 Broadcast方法实现

Broadcast方法调用runtime_notifyListNotifyAll唤醒所有处于等待状态的协程。

1. func (c *Cond) Broadcast() {
2.    // 唤醒等待队列中所有的协程
3.    runtime_notifyListNotifyAll(&c.notify)
4. }

复制代码

4.使用注意事项

4.1 调用Wait方法前未加锁

4.1.1 问题

如果在调用Wait方法前未加锁，此时会直接panic，下面是一个简单例子的说明:

1. package main
3. import (
4.     "fmt"
5.     "sync"
6.     "time"
7. )
9. var (
10.    count int
11.    cond  *sync.Cond
12.    lk    sync.Mutex
13. )
15. func main() {
16.     cond = sync.NewCond(&lk)
17.     wg := sync.WaitGroup{}
18.     wg.Add(2)
19.     go func() {
20.        defer wg.Done()
21.        for {
22.           time.Sleep(time.Second)
23.           count++
24.           cond.Broadcast()
25.        }
26.     }()
27.    
28.     go func() {
29.        defer wg.Done()
30.        for {
31.           time.Sleep(time.Millisecond * 500)         
32.           //cond.L.Lock()
33.           for count%10 != 0 {
34.                cond.Wait()
35.           }
36.           t.Logf("count = %d", count)
37.           //cond.L.Unlock()  
38.        }
39.     }()
40.     wg.Wait()
41. }

复制代码

上面代码中，协程一每隔1s，将count字段的值自增1，然后唤醒所有处于等待状态的协程。协程二执行的条件为count的值为10的倍数，此时满足执行条件，唤醒后将会继续往下执行。
但是这里在调用sync.Wait方法前，没有先获取锁，下面是其执行结果，会抛出 fatal error: sync: unlock of unlocked mutex 错误，结果如下:

1. count = 0
2. fatal error: sync: unlock of unlocked mutex

复制代码

因此，在调用Wait方法前，需要先获取到与sync.Cond关联的锁，否则会直接抛出异常。
4.1.2 为什么调用Wait方法前需要先获取该锁

强制调用Wait方法前需要先获取该锁。这里的原因在于调用Wait方法如果不加锁，有可能会出现竞态条件。
这里假设多个协程都处于等待状态，然后一个协程调用了Broadcast唤醒了其中一个或多个协程，此时这些协程都会被唤醒。
如下，假设调用Wait方法前没有加锁的话，那么所有协程都会去调用condition方法去判断是否满足条件，然后都通过验证，执行后续操作。

1. for !condition() {
2.     c.Wait()
3. }
4. c.L.Lock()
5. // 满足条件情况下,执行的逻辑
6. c.L.Unlock()

复制代码

此时会出现的情况为，本来是需要在满足condition方法的前提下，才能执行的操作。现在有可能的效果，为前面一部分协程执行时，还是满足condition条件的；但是后面的协程，尽管不满足condition条件，还是执行了后续操作，可能导致程序出错。
正常的用法应该是，在调用Wait方法前便加锁，只会有一个协程判断是否满足condition条件，然后执行后续操作。这样子就不会出现即使不满足条件，也会执行后续操作的情况出现。

1. c.L.Lock()
2. for !condition() {
3.     c.Wait()
4. }
5. // 满足条件情况下,执行的逻辑
6. c.L.Unlock()

复制代码

4.2 Wait方法接收到通知后，未重新检查条件变量

调用sync.Wait方法，协程进入阻塞状态后被唤醒，没有重新检查条件变量，此时有可能仍然处于不满足条件变量的场景下。然后直接执行后续操作，有可能会导致程序出错。下面举一个简单的例子:

1. package main
3. import (
4.     "fmt"
5.     "sync"
6.     "time"
7. )
9. var (
10.    count int
11.    cond  *sync.Cond
12.    lk    sync.Mutex
13. )
15. func main() {
16.     cond = sync.NewCond(&lk)
17.     wg := sync.WaitGroup{}
18.     wg.Add(3)
19.     go func() {
20.        defer wg.Done()
21.        for {
22.           time.Sleep(time.Second)
23.           cond.L.Lock()
24.           // 将flag 设置为true
25.           flag = true
26.           // 唤醒所有处于等待状态的协程
27.           cond.Broadcast()
28.           cond.L.Unlock()
29.        }
30.     }()
31.    
32.     for i := 0; i < 2; i++ {
33.        go func(i int) {
34.           defer wg.Done()
35.           for {
36.              time.Sleep(time.Millisecond * 500)
37.              cond.L.Lock()
38.              // 不满足条件，此时进入等待状态
39.              if !flag {
40.                 cond.Wait()
41.              }
42.              // 被唤醒后，此时可能仍然不满足条件
43.              fmt.Printf("协程 %d flag = %t", i, flag)
44.              flag = false
45.              cond.L.Unlock()
46.           }
47.        }(i)
48.     }
49.     wg.Wait()
50. }

复制代码

在这个例子，我们启动了一个协程，定时将flag设置为true，相当于每隔一段时间，便满足执行条件，然后唤醒所有处于等待状态的协程。
然后又启动了两个协程，在满足条件的前提下，开始执行后续操作，但是这里协程被唤醒后，没有重新检查条件变量，具体看第39行。这里会出现的场景是，第一个协程被唤醒后，此时执行后续操作，然后将flag重新设置为false，此时已经不满足条件了。之后第二个协程唤醒后，获取到锁，没有重新检查此时是否满足执行条件，直接向下执行，这个就和我们预期不符，可能会导致程序出错，代码执行效果如下:

1. 协程 1 flag = true
2. 协程 0 flag = false
3. 协程 1 flag = true
4. 协程 0 flag = false

复制代码

可以看到，此时协程0执行时，flag的值均为false,说明此时其实并不符合执行条件，可能会导致程序出错。因此正确用法应该像下面这样子，被唤醒后，需要重新检查条件变量，满足条件之后才能继续向下执行。

1. c.L.Lock()
2. // 唤醒后,重新检查条件变量是否满足条件
3. for !condition() {
4.     c.Wait()
5. }
6. // 满足条件情况下,执行的逻辑
7. c.L.Unlock()

复制代码

5.总结

本文介绍了 Go 语言中的 sync.Cond 并发原语，它是用于实现 goroutine 之间的同步的重要工具。我们首先学习了 sync.Cond 的基本使用方法，包括创建和使用条件变量、使用Wait和Signal/Broadcast方法等。
在接下来的部分中，我们介绍了 sync.Cond 的实现原理，主要是对等待队列的使用，从而sync.Cond有更好的理解，能够更好得使用它。同时，我们也讲述了使用sync.Cond的注意事项，如调用Wait方法前需要加锁等。
基于以上内容，本文完成了对 sync.Cond 的介绍，希望能够帮助大家更好地理解和使用Go语言中的并发原语。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！