Golang sync.Cond 应用详解

sync.Cond 简介

Cond 实现了一个条件变量，在 Locker 的基础上增加的一个消息通知的功能，保存了一个通知列表，
用来唤醒一个或所有因等待条件变量而阻塞的 Go 程，以此来实现多个 Go 程间的同步。
go原生支持的功能,可以到 go/src 源码中,根据关键字搜索相关内容。

type Cond struct {
    // L is held while observing or changing the condition
	L Locker
	// contains filtered or unexported fields
}

func NewCond(l Locker) *Cond // 创建一个带锁的条件变量,Locker 通常是一个 *Mutex 或 *RWMutex

func (c *Cond) Broadcast()	 // 唤醒所有因等待条件变量 c 阻塞的 goroutine

func (c *Cond) Signal()		 // 唤醒一个因等待条件变量 c 阻塞的 goroutine

func (c *Cond) Wait()		 // 等待 c.L 解锁并挂起 goroutine，在稍后恢复执行后，Wait 返回前锁定 c.L，只有当被 Broadcast 和 Signal 唤醒，Wait 才能返回

注意：在调用 Signal，Broadcast 之前，应确保目标 Go 程进入 Wait 阻塞状态。

NewCond() 函数

相当于Cond的构造函数，用于初始化Cond。
参数为Locker实例初始化,传参数的时候必须是引用或指针,比如&sync.Mutex{}或new(sync.Mutex).

func NewCond(l Locker) *Cond {
	return &Cond{L: l}
}

Wait 函数

等待自动解锁c.L和暂停执行调用goroutine。恢复执行后,等待锁c.L返回之前。

func (c *Cond) Wait() {
    // 检查c是否是被复制的，如果是就panic
	c.checker.check()
	// 将当前goroutine加入等待队列
	t := runtime_notifyListAdd(&c.notify)
	// 解锁
	c.L.Unlock()
	// 等待队列中的所有的goroutine执行等待唤醒操作
	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

判断cond是否被复制。

type copyChecker uintptr

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")
	}
}

Signal 函数

唤醒等待队列中的一个goroutine，一般都是任意唤醒队列中的一个goroutine，
为什么没有选择FIFO的模式呢？这是因为FiFO模式效率不高，虽然支持，但是很少使用到。

func (c *Cond) Signal() {
    // 检查c是否是被复制的，如果是就panic
	c.checker.check()
	// 通知等待列表中的一个 
	runtime_notifyListNotifyOne(&c.notify)
}

Broadcast 函数

唤醒等待队列中的所有goroutine。

func (c *Cond) Broadcast() {
    // 检查c是否是被复制的，如果是就panic
	c.checker.check()
	// 唤醒等待队列中所有的goroutine
	runtime_notifyListNotifyAll(&c.notify)
}

实例

package main

import (
        "fmt"
        "sync"
        "time"
)

var (
        locker = new(sync.Mutex)
        cond = sync.NewCond(locker)
        maxCond = 15
)

func main(){

        for i := 0; i < maxCond; i++ {
                go func(x int) {
                        cond.L.Lock()
                        defer cond.L.Unlock()

                        cond.Wait()

                        fmt.Printf("process num: %d \n",x)
                        time.Sleep(200 * time.Millisecond)
                }(i)
        }

        time.Sleep(1 * time.Second)
        var i int
        for i = 0; i < maxCond - 5; i++ {
                cond.Signal()
                time.Sleep(250 * time.Millisecond)
        }
        fmt.Printf("send signal %d \n",i)

        cond.Broadcast()
        fmt.Printf("send boardcast signel \n")
        time.Sleep(5  * time.Second)
}

//运行效果如下

robot@ubuntu:~/gomod/src/sync$ go run syncCond.go 
process num: 14 
process num: 0 
process num: 1 
process num: 2 
process num: 3 
process num: 4 
process num: 5 
process num: 6 
process num: 7 
process num: 8 
send signal 10 
send boardcast signel 
process num: 13 
process num: 9 
process num: 10 
process num: 11 
process num: 12