Golang sync.Cond源码分析

cond的主要做用就是获取锁以后，wait()方法会等待一个通知，来进行下一步锁释放等操做，以此控制锁合适释放，释放频率,适用于在并发环境下goroutine的等待和通知。

针对Golang 1.9的sync.Cond，与Golang 1.10同样。 源代码位置：sync\cond.go。

结构体

type Cond struct {
	noCopy noCopy  // noCopy能够嵌入到结构中，在第一次使用后不可复制,使用go vet做为检测使用

	// 根据需求初始化不一样的锁，如*Mutex 和 *RWMutex
	L Locker

	notify  notifyList  // 通知列表,调用Wait()方法的goroutine会被放入list中,每次唤醒,从这里取出
	checker copyChecker // 复制检查,检查cond实例是否被复制
}

再来看看等待队列notifyList结构体：

type notifyList struct {
	wait   uint32
	notify uint32
	lock   uintptr
	head   unsafe.Pointer
	tail   unsafe.Pointer
}

函数

NewCond

至关于Cond的构造函数，用于初始化Cond。

参数为Locker实例初始化,传参数的时候必须是引用或指针,好比&sync.Mutex{}或new(sync.Mutex)，否则会报异常:cannot use lock (type sync.Mutex) as type sync.Locker in argument to sync.NewCond。
你们能够想一想为何必定要是指针呢？ 知道的能够给我留言回答。

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

Wait

等待自动解锁c.L和暂停执行调用goroutine。恢复执行后,等待锁c.L返回以前。与其余系统不一样，等待不能返回，除非经过广播或信号唤醒。

由于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)
var cond = sync.NewCond(locker)

func main() {
	for i := 0; i < 40; i++ {
		go func(x int) {
			cond.L.Lock()         //获取锁
			defer cond.L.Unlock() //释放锁
			cond.Wait()           //等待通知,阻塞当前goroutine
			fmt.Println(x)
			time.Sleep(time.Second * 1)

		}(i)
	}
	time.Sleep(time.Second * 1)
	fmt.Println("Signal...")
	cond.Signal() // 下发一个通知给已经获取锁的goroutine
	time.Sleep(time.Second * 1)
	cond.Signal() // 3秒以后 下发一个通知给已经获取锁的goroutine
	time.Sleep(time.Second * 3)
	cond.Broadcast() //3秒以后 下发广播给全部等待的goroutine
	fmt.Println("Broadcast...")
	time.Sleep(time.Second * 60)
}