我怎么从来没见过 sync.Cond

package main

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

func main() {
   cond := sync.NewCond(&sync.Mutex{})
   go func() {
      cond.L.Lock()
      fmt.Println("a is waiting...")
      cond.Wait()
      fmt.Println("a was awakened")
      cond.L.Unlock()
   }()
   go func() {
      cond.L.Lock()
      fmt.Println("b is waiting...")
      cond.Wait()
      fmt.Println("b was awakened")
      cond.L.Unlock()
   }()
   time.Sleep(time.Second)
   cond.Signal()
   time.Sleep(time.Second)
   cond.Signal()
   time.Sleep(time.Second)
}

output: 
a is waiting...
b is waiting...
a was awakened
b was awakened

type Cond struct {
   noCopy noCopy

   // L is held while observing or changing the condition
   L Locker

   notify  notifyList
   checker copyChecker
}

type notifyList struct {
	// wait is the ticket number of the next waiter. It is atomically
	// incremented outside the lock.
	wait uint32

	// notify is the ticket number of the next waiter to be notified. It can
	// be read outside the lock, but is only written to with lock held.
	//
	// Both wait & notify can wrap around, and such cases will be correctly
	// handled as long as their "unwrapped" difference is bounded by 2^31.
	// For this not to be the case, we'd need to have 2^31+ goroutines
	// blocked on the same condvar, which is currently not possible.
	notify uint32

	// List of parked waiters.
	lock mutex
	head *sudog
	tail *sudog
}

// NewCond returns a new Cond with Locker l.
func NewCond(l Locker) *Cond {
   return &Cond{L: l}
}

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

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

func (c *Cond) Wait() {
   c.checker.check()
   t := runtime_notifyListAdd(&c.notify)
   c.L.Unlock()
   runtime_notifyListWait(&c.notify, t)
   c.L.Lock()
}

// notifyListAdd adds the caller to a notify list such that it can receive
// notifications. The caller must eventually call notifyListWait to wait for
// such a notification, passing the returned ticket number.
//go:linkname notifyListAdd sync.runtime_notifyListAdd
func notifyListAdd(l *notifyList) uint32 {
   // This may be called concurrently, for example, when called from
   // sync.Cond.Wait while holding a RWMutex in read mode.
   return atomic.Xadd(&l.wait, 1) - 1
}

// notifyListAdd was called, it returns immediately. Otherwise, it blocks.
//go:linkname notifyListWait sync.runtime_notifyListWait
func notifyListWait(l *notifyList, t uint32) {
   lockWithRank(&l.lock, lockRankNotifyList)

   // Return right away if this ticket has already been notified.
   if less(t, l.notify) {
      unlock(&l.lock)
      return
   }

   // Enqueue itself.
   s := acquireSudog()
   s.g = getg()
   s.ticket = t
   s.releasetime = 0
   t0 := int64(0)
   if blockprofilerate > 0 {
      t0 = cputicks()
      s.releasetime = -1
   }
   if l.tail == nil {
      l.head = s
   } else {
      l.tail.next = s
   }
   l.tail = s
   goparkunlock(&l.lock, waitReasonSyncCondWait, traceEvGoBlockCond, 3)
   if t0 != 0 {
      blockevent(s.releasetime-t0, 2)
   }
   releaseSudog(s)
}

// notifyListNotifyOne notifies one entry in the list.
//go:linkname notifyListNotifyOne sync.runtime_notifyListNotifyOne
func notifyListNotifyOne(l *notifyList) {
   // Fast-path: if there are no new waiters since the last notification
   // we don't need to acquire the lock at all.
   if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
      return
   }

   lockWithRank(&l.lock, lockRankNotifyList)

   // Re-check under the lock if we need to do anything.
   t := l.notify
   if t == atomic.Load(&l.wait) {
      unlock(&l.lock)
      return
   }

   // Update the next notify ticket number.
   atomic.Store(&l.notify, t+1)

   // Try to find the g that needs to be notified.
   // If it hasn't made it to the list yet we won't find it,
   // but it won't park itself once it sees the new notify number.
   //
   // This scan looks linear but essentially always stops quickly.
   // Because g's queue separately from taking numbers,
   // there may be minor reorderings in the list, but we
   // expect the g we're looking for to be near the front.
   // The g has others in front of it on the list only to the
   // extent that it lost the race, so the iteration will not
   // be too long. This applies even when the g is missing:
   // it hasn't yet gotten to sleep and has lost the race to
   // the (few) other g's that we find on the list.
   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)
}

// notifyListNotifyAll notifies all entries in the list.
//go:linkname notifyListNotifyAll sync.runtime_notifyListNotifyAll
func notifyListNotifyAll(l *notifyList) {
   // Fast-path: if there are no new waiters since the last notification
   // we don't need to acquire the lock.
   if atomic.Load(&l.wait) == atomic.Load(&l.notify) {
      return
   }

   // Pull the list out into a local variable, waiters will be readied
   // outside the lock.
   lockWithRank(&l.lock, lockRankNotifyList)
   s := l.head
   l.head = nil
   l.tail = nil

   // Update the next ticket to be notified. We can set it to the current
   // value of wait because any previous waiters are already in the list
   // or will notice that they have already been notified when trying to
   // add themselves to the list.
   atomic.Store(&l.notify, atomic.Load(&l.wait))
   unlock(&l.lock)

   // Go through the local list and ready all waiters.
   for s != nil {
      next := s.next
      s.next = nil
      readyWithTime(s, 4)
      s = next
   }
}