条件变量Cond实现

type Record struct {
 sync.Mutex
 data string
}

func main() {
 var wg sync.WaitGroup

 rec := &Record{}
 wg.Add(1)
 go func(rec *Record) {
  defer wg.Done()
  for {
   rec.Lock()
   if rec.data != "" {
    fmt.Println("Data: ", rec.data)
    rec.Unlock()
    return
   }
   rec.Unlock()
  }
 }(rec)

 time.Sleep(2 * time.Second)
 rec.Lock()
 rec.data = "gopher"
 rec.Unlock()

 wg.Wait()
}

type Record struct {
 sync.Mutex
 data string

 cond *sync.Cond
}

func NewRecord() *Record {
 r := Record{}
 r.cond = sync.NewCond(&r)

 return &r
}

func main() {
 var wg sync.WaitGroup

 rec := NewRecord()
 wg.Add(1)
 go func(rec *Record) {
  defer wg.Done()

  rec.Lock()
  rec.cond.Wait()
  rec.Unlock()
  fmt.Println("Data: ", rec.data)
  return
 }(rec)

 time.Sleep(2 * time.Second)
 rec.Lock()
 rec.data = "gopher"
 rec.Unlock()
 rec.cond.Signal()

 wg.Wait()
}

type Cond struct {
 noCopy noCopy

 // 当观察或修改等待条件的时候需要加锁
 L Locker
 // 等待队列
 notify  notifyList
 checker copyChecker
}

type Locker interface {
 Lock()
 Unlock()
}

type notifyList struct {
 // wait是一个计数器，它的值为调用Wait的goroutine的编号
 wait uint32
 // notify也是一个计数器，它的值表示调用Signal或者Broadcast时唤醒阻塞在[notify,wait)
 // 范围编号上的goroutine
 notify uint32
 lock   uintptr
 // head是一个指针，指向sudog单链表的头节点，阻塞g的队列中第一个g的位置
 head unsafe.Pointer
 // tail也是一个指针，指向sudog单链表的尾节点，阻塞g的队列中最后一个g的位置
 tail unsafe.Pointer
}

func (c *Cond) Wait() {
 // 检查Cond对象是否被复制过
 c.checker.check()
 // wait自增1
 t := runtime_notifyListAdd(&c.notify)
 // 释放锁，所以在调用Wait前，必须进行加锁
 c.L.Unlock()
 // 将当前的goroutine挂起阻塞等待在notify队列上，收到唤醒信号之后
 // 恢复运行
 runtime_notifyListWait(&c.notify, t)
 // 加锁，在执行Wait之后的代码前，Cond又被加锁了
 c.L.Lock()
}

func notifyListAdd(l *notifyList) uint32 {
 // 将wait的值原子性操作自增1，wait的初始值为0
 return atomic.Xadd(&l.wait, 1) - 1
}

func notifyListWait(l *notifyList, t uint32) {
 lock(&l.lock)

 // 小于notify的值的对应编号阻塞的goroutine之前已经唤醒过了，直接返回
 if less(t, l.notify) {
  unlock(&l.lock)
  return
 }

 // 获取一个sudog对象s
 s := acquireSudog()
 // 设置s中的g为当前的goroutine
 s.g = getg()
 // 设置ticket值为传入的t,可以理解为ticket与当前阻塞的goroutine(s.g)对应
 s.ticket = t
 s.releasetime = 0
 t0 := int64(0)
 if blockprofilerate > 0 {
  t0 = cputicks()
  s.releasetime = -1
 }
 // 将新创建的sudog对象s加入到队列的尾部，这个过程是在lock加锁的条件下进行的
 // 不用担心并发将s加入到l.tail冲突问题
 if l.tail == nil {
  l.head = s
 } else {
  l.tail.next = s
 }
 l.tail = s
 // 调用gopark阻塞当前的goroutine运行
 goparkunlock(&l.lock, waitReasonSyncCondWait, traceEvGoBlockCond, 3)
 if t0 != 0 {
  blockevent(s.releasetime-t0, 2)
 }
 releaseSudog(s)
}

func (c *Cond) Signal() {
 c.checker.check()
 // 唤醒notifyList队列中队头的goroutine
 runtime_notifyListNotifyOne(&c.notify)
}

func notifyListNotifyOne(l *notifyList) {
 // 如果wait和notify值相等，说明没有阻塞等待的goroutine，也就没有要唤醒的g了，这里直接返回
 if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
  return
 }
 // 加锁执行下面操作
 lock(&l.lock)

 // 加锁后再次检查wait的值跟notify是否相等，如果相等同上直接释放锁返回
 t := l.notify
 if t == atomic.Load(&l.wait) {
  unlock(&l.lock)
  return
 }

 // notify加1，相当于消费者消费一个数据(g)，下面会将队列头的goroutine唤醒
 atomic.Store(&l.notify, t+1)
 // 执行循环操作，从队列中找出ticket等于notify(l.notify-1，因为此时l.notify已加1)的sudog对象
 // 从sudog对象中获取到绑定的g,然后执行readyWithTime，readyWithTime会调用goread将g唤醒
 for p, s := (*sudog)(nil), l.head; s != nil; p, s = s, s.next {
  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
   readyWithTime(s, 4)
   return
  }
 }
 // 释放锁
 unlock(&l.lock)
}

func (c *Cond) Broadcast() {
 c.checker.check()
 // 唤醒notifyList队列中所有的goroutine
 runtime_notifyListNotifyAll(&c.notify)
}

func notifyListNotifyAll(l *notifyList) {
 // 如果wait和notify值相等，说明没有阻塞等待的goroutine，也就没有要唤醒的g了，这里直接返回
 if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
  return
 }

 // 加锁，将当前链表拷贝到临时变量s中，然后将原链表释放
 // 之后就可以解锁了。通过是拷贝方式达到快速解锁，这里比
 // 锁的粒度比Signal还要小。
 lock(&l.lock)
 s := l.head
 l.head = nil
 l.tail = nil

 // 原子将wait的值赋值给notify，表示[notify,wait)范围内阻塞的goroutine都将被唤醒了
 atomic.Store(&l.notify, atomic.Load(&l.wait))
 unlock(&l.lock)

 // 遍历链表中每一个sudog对象，将绑定在sudog对象上的goroutine唤醒
 for s != nil {
  next := s.next
  s.next = nil
  // readyWithTime会调用goready将goroutine唤醒
  readyWithTime(s, 4)
  s = next
 }
}

package main

import (
    "sync"
    "time"
)

func main() {
    m := sync.Mutex{}
    c := sync.NewCond(&m)
    go func() {
        time.Sleep(1 * time.Second)
        c.Broadcast()
    }()
    m.Lock()
    time.Sleep(2 * time.Second)
    c.Wait()
}

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