golang sync.Cond使用和实现原理

func TestCond(t *testing.T) {
	var locker = new(sync.Mutex)
	var cond = sync.NewCond(locker)
	for i := 0; i < 10; i++ {
		go func(x int) {
			cond.L.Lock()         //获取锁
			defer cond.L.Unlock() //释放锁
			cond.Wait()           //等待通知,阻塞当前goroutine
			fmt.Println(x)
		}(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...")
	
	select {}
}

运行结果：
=== RUN   TestCond
Signal...
0
1
Broadcast...
2
6
4
5
7
3
9
8

type Cond struct {
    noCopy noCopy       // 不可复制
    L Locker            // 锁
    notify  notifyList  // 通知唤起列表
    checker copyChecker // 复制检测，禁止第一次使用的Cond被复制拷贝
}

type notifyList struct {
	wait   uint32         // 当前wait的index
	notify uint32         // 当前notify的index
	lock   uintptr        // 锁
	head   unsafe.Pointer // 队头
	tail   unsafe.Pointer // 队尾
}

func (c *Cond) Wait() {
	c.checker.check() // copy 检查
	t := runtime_notifyListAdd(&c.notify) // 向通知列表列表中加入该通知
	c.L.Unlock() // 暂时解锁
	runtime_notifyListWait(&c.notify, t) //通知操作
	c.L.Lock() //加锁，还原状态
}

//go:linkname notifyListAdd sync.runtime_notifyListAdd
func notifyListAdd(l *notifyList) uint32 {
	// 更新wait的index
	return atomic.Xadd(&l.wait, 1) - 1
}

//go:linkname notifyListWait sync.runtime_notifyListWait
func notifyListWait(l *notifyList, t uint32) {
	lockWithRank(&l.lock, lockRankNotifyList)

	// 判断需要等待notify的index是否合法
	if less(t, l.notify) {
		unlock(&l.lock)
		return
	}

	// 获取当前的sudog
	s := acquireSudog()
	s.g = getg()
    // sudog设置ticket
    s.ticket = t
    // 加入到队尾
	if l.tail == nil {
		l.head = s
	} else {
		l.tail.next = s
	}
	l.tail = s
    // gopark阻塞等待被唤醒
	goparkunlock(&l.lock, waitReasonSyncCondWait, traceEvGoBlockCond, 3)
	releaseSudog(s)
}

c.L.Lock()
for !condition() {
    c.Wait()
}
//    ... make use of condition ...
c.L.Unlock()

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

func (c *Cond) Signal() {
	c.checker.check()
	runtime_notifyListNotifyOne(&c.notify)
}

//go:linkname notifyListNotifyOne sync.runtime_notifyListNotifyOne
func notifyListNotifyOne(l *notifyList) {
	// 所有wait已经全部被notify
	if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
		return
	}

	lockWithRank(&l.lock, lockRankNotifyList)

	// Lock之后再次检查是否还有wait需要notify.
	t := l.notify
	if t == atomic.Load(&l.wait) {
		unlock(&l.lock)
		return
	}

	// 更新notify的index.
	atomic.Store(&l.notify, t+1)
    // 遍历notifyList中的sudog队列
	for p, s := (*sudog)(nil), l.head; s != nil; p, s = s, s.next {
        // 根据wait设置的ticket找到对应的sudog
		if s.ticket == t {
			n := s.next
			if p != nil {
				p.next = n
			} else {
				l.head = n
			}
			if n == nil {
				l.tail = p
			}
			unlock(&l.lock)
			s.next = nil
            // 执行goready，唤醒对应的sudog
			readyWithTime(s, 4)
			return
		}
	}
	unlock(&l.lock)
}

func (c *Cond) Broadcast() {
	c.checker.check()
	runtime_notifyListNotifyAll(&c.notify)
}

//go:linkname notifyListNotifyAll sync.runtime_notifyListNotifyAll
func notifyListNotifyAll(l *notifyList) {
	// 检查是否所有的wait都已经被唤醒
	if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
		return
	}

	lockWithRank(&l.lock, lockRankNotifyList)
    // broadcast是唤醒所有的waits，可以清除等待的队列
	s := l.head
	l.head = nil
	l.tail = nil

	// 直接更新notify的index为wait，表示全部已经被notify
	atomic.Store(&l.notify, atomic.Load(&l.wait))
	unlock(&l.lock)

	// 唤醒所有的sudog
	for s != nil {
		next := s.next
		s.next = nil
		readyWithTime(s, 4)
		s = next
	}
}