【并发编程】Cond 基本用法和如何实现以及常见错误

大家好，欢迎来到IT知识分享网。

博主介绍：

– 我是了 凡 微信公众号【了凡银河系】期待你的关注。未来大家一起加油啊~

前言

一个常见的面试问题就是关于等待/通知（wait/notify）机制：例如请实现一个限定容量的队列（queue），当队列满或者空的时候，利用等待/通知机制实现阻塞或者唤醒。

Go语言中提供了一个类似的限定容量的队列，只要用条件变量（Cond）并发原语就可以。Cond并发原语相对来说不是那么常用，但在特定的场景使用会事半功倍，比如需要在唤醒一个或者所有的等待者做一些检查操作的时候。

Cond是什么？

Cond是Go标准库提供的原语，是为了给等待/通知场景下的并发问题提供支持。 Cond通常应用于等待某个条件的一组goroutine，等条件变为true的时候，其中一个goroutine或者所有的goroutine都会被唤醒执行。

顾名思义，Cond是和某个条件相关，这个条件需要一组goroutine写作共同完成，在条件还没有满足的时候，所有等待这个条件的groutine都会被阻塞住，只有这一组goroutine通过协议达到了这个条件，等待的goroutine次啊可以继续进行下去。

这有个问题，等待的条件是什么？条件是某个变量达到了某个阈值或者某个时间点，也可以是一组变量分别都达到了某个阈值，还可以是某个对象的状态满足了待定的条件。

总结：等待的条件是一种可以用来计算结果是true还是false的条件。

Cond基础用法

type Cond func NewCond(l Locker) *Cond func (c *Cond) Broadcast() func (c *Cond) Signal() func (c *Cond) Wait() 

Cond关联的Locker实例可以通过c.L访问，它内部维护着一个先入先出的等待队列。

看一下以上的三个方法Signal、Broadcast、Wait方法。（我只在操作系统里见到了Signal和Wait，没有见过Broadcast方法，接下来看下都有什么功能吧）

• Signal方法：允许调用者Caller唤醒一个等待此Cond和goroutine。如果此时没有等待的goroutine，显然无需通知waiter；如果Cond等待队列中有一个或者多个等待的goroutine，则需要从等待队列中移除第一个goroutine并把它唤醒。在Java语言中，Signal方法也叫做notify方法。调用Signal方法时，不强求你一定要持有c.L的锁。
• Broadcast方法，允许调用者Caller唤醒所有等待此Cond的goroutine。如果此时没有等待的goroutine，显然无需通知waiter；如果Cond等待队列中有一个或者多个等待的goroutine，则清空所有等待的goroutine，并全部唤醒。在Java语言中，Broadcast方法也被叫做notifyAll方法。同样地，调用Broadcast方法时，也不强求你一定持有c.L的锁。
• Wait方法，会把调用者Caller放入Cond的等待队列中并阻塞，直到被Signal或者Broadcast的方法从等待队列中移除并唤醒。调用Wait方法时必须要持有c.L的锁。

Go实现的sync.Cond的方法名是Wait、Signal和Broadcast，这是计算机科学中条件变量的通用方法名。C语言对应的方法名是pthread_cond_wait、pthread_cond_signal和pthread_cond_broadcast。

接下来，看一个百米赛跑开始时的例子，来学习Cond的使用方法。10个运动员进入赛场之后需要先做拉伸活动活动筋骨，向观众和粉丝招手致敬，在自己的赛道上做好准备；等所有的运动员都准好之后，裁判员才会打响发令枪。

每个运动员做好准备之后，将ready加一，表明自己做好准备了，同时调用Broadcast方法通知裁判员。因为裁判员只有一个，所以这里可以直接替换成Signal方法调用。

裁判员会等待运动员都准备好（第22行）。虽然每个运动员准备好之后都唤醒了裁判员，但是裁判员被唤醒之后需要检查等待条件是否满足（运动员都准备好了）。可以看到，裁判员被唤醒之后一定要检查等待条件，如果条件不满足还是要继续等待。

func main(){ 
    c := sync.NewCond(&sync.Mutex{ 
   }) var ready int for i := 0; i < 10; i++ { 
    go func(i int) { 
    time.Sleep(time.Duration(rand.Int63n(10)) * time.Second) // 加锁更改等待条件 c.L.Lock() ready ++ c.L.Unlock() log.Printf("运动员#%d 已准备就绪\n", i) // 广播唤醒所有的等待者 c.Broadcast() }(i) } c.L.Lock() for ready != 10 { 
    c.Wait() log.Println("裁判员被唤醒一次") } c.L.Unlock() // 所有的运动员是否就绪 log.Println("所有运动员都准备就绪。比赛开始，3，2，1， ......") } 

执行结果

Cond的使用其实没那么简单。
复杂在于：

• 一，这段代码有时候需要加锁，有时候可以不加；
• 二，Wait唤醒后需要检查条件；
• 三，条件变量的更改，其实是需要原子操作或者互斥锁保护的。

Cond实现原理

Cond本身实现还是比较简单的，复杂的逻辑都在Locker或者runtime的等待队列实现了。（由于为了更加清晰一点，有一些源码都拉出来会比较多，耐心看完）

type noCopy struct{ 
   } type Locker interface { 
    Lock() Unlock() } type notifyList struct { 
    wait uint32 notify uint32 lock uintptr head unsafe.Pointer tail unsafe.Pointer } type copyChecker uintptr type Cond struct { 
    noCopy noCopy // 当观察或者修改等待条件的时候需要加锁 L Locker // 等待队列 notify notifyList checker copyChecker } func (c *copyChecker) check() { 
    if uintptr(*c) != uintptr(unsafe.Pointer(c)) && !atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) && uintptr(*c) != uintptr(unsafe.Pointer(c)) { 
    panic("sync.Cond is copied") } } func NewCond(l Locker) *Cond { 
    return &Cond{ 
   L: l} } func (c *Cond) Wait() { 
    c.checker.check() // 增加到等待队列中 t := runtime_notifyListAdd(&c.notify) c.L.Unlock() // 阻塞休眠直到被唤醒 runtime_notifyListWait(&c.notify, t) c.L.Lock() } func (c *Cond) Signal() { 
    c.checker.check() runtime_notifyListNotifyOne(&c.notify) } func (c *Cond) Broadcast() { 
    c.checker.check() runtime_notifyListNotifyAll(&c.notify) } 

1. runtime_notifyListXXX
   是运行时实现的方法（之前的文章应该有看到过），实现了一个等待/通知的队列。如果想深入学习这部分，可以去看看runtime/sema.go代码中。
2. copyChecker是一个辅助结构，可以在运行时检查Cond是否复制使用。
3. Signal和Broadcast只涉及到notifyList数据结构，不涉及到锁。
4. Wait把调用者加入到等待队列时会释放锁，在被唤醒之后还会请求锁。在阻塞休眠期间，调用者是不持有锁的，这样能让其他goroutine有机会检查或者过呢更新等待变量。

Cond的常见错误

第一个是调用Wait的时候没有加锁

以百米赛跑为例，在调用cond.Wait时，把前后的Lock/Unlock注释掉，比如以下代码第20行和第25行

func main(){ 
    c := sync.NewCond(&sync.Mutex{ 
   }) var ready int for i := 0; i < 10; i++ { 
    go func(i int) { 
    time.Sleep(time.Duration(rand.Int63n(10)) * time.Second) // 加锁更改等待条件 c.L.Lock() ready ++ c.L.Unlock() log.Printf("运动员#%d 已准备就绪\n", i) // 广播唤醒所有的等待者 c.Broadcast() }(i) } //c.L.Lock() for ready != 10 { 
    c.Wait() log.Println("裁判员被唤醒一次") } //c.L.Unlock() // 所有的运动员是否就绪 log.Println("所有运动员都准备就绪。比赛开始，3，2，1， ......") 

执行结果：

会发现上面报了Unlock of unlocked mutex 未加锁的panic，这个panic的原因在于，cond.Wait方法的实现是，把当前调用者加入到notify队列之中后会释放锁（如果不释放锁，其他Wait的调用者就没有机会加入到notify队列中了），然后一直等待；等调用者被唤醒之后，又会去争抢这把锁。如果调用Wait之前不加锁的话，就有可能Unlock一个未加锁的Locker。所以，调用cond.Wait方法之前一定要加锁。

第二个是没有检查条件是否满足程序就继续执行

这个问题原因是，误以为Cond的使用，就像WaitGroup那样调用一下Wait方法等待那么简单。例如还是上个问题，把21行和24行注释掉：

func main(){ 
    c := sync.NewCond(&sync.Mutex{ 
   }) var ready int for i := 0; i < 10; i++ { 
    go func(i int) { 
    time.Sleep(time.Duration(rand.Int63n(10)) * time.Second) // 加锁更改等待条件 c.L.Lock() ready ++ c.L.Unlock() log.Printf("运动员#%d 已准备就绪\n", i) // 广播唤醒所有的等待者 c.Broadcast() }(i) } c.L.Lock() //for ready != 10 { 
    c.Wait() log.Println("裁判员被唤醒一次") //} c.L.Unlock() // 所有的运动员是否就绪 log.Println("所有运动员都准备就绪。比赛开始，3，2，1， ......") } 

运行结果：

可以看到，没有将所有的运动员都执行完，不是我们想的的那样所有运动员都准备好才进行下一步。原因在于，每一个运动员准备好之后都会唤醒所有的等待者，也就是这里的裁判员，比如第一个运动员准备好后就唤醒了裁判员，结果这个裁判员傻傻地没做任何检查，以为所有的运动员都准备好了，就继续执行了。

所以，waiter goroutine被唤醒不等于等待条件满足，只用goroutine把它唤醒了而已，等待条件有可能已经满足了，也有可能不满足，需要进一步检查。也可以说，等待者被唤醒，知识的呢到了一次检查的机会而已。

总结

时刻记住调用cond.Wait方法前一定要加锁，以及waiter goroutine被唤醒不等于等待条件被满足。