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 atomic.Uint32 // 下一个等待着应该持有ticket

	// 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 //下一个被唤醒的goroutine的ticket

	// List of parked waiters.
	lock mutex // 保护链表的锁
	head *sudog // 链表的头部
	tail *sudog //链表的尾部
}

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 l.wait.Add(1) - 1
}

// notifyListWait waits for a notification. If one has been sent since
// 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, traceBlockCondWait, 3)
	if t0 != 0 {
		blockevent(s.releasetime-t0, 2)
	}
	releaseSudog(s)
}

// 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 l.wait.Load() == 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, l.wait.Load())
	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
	}
}

// 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 l.wait.Load() == 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 == l.wait.Load() {
		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)
}

func (c *Cond) Wait() {
	c.checker.check()
	t := runtime_notifyListAdd(&c.notify) // 先加入通知列表中
	c.L.Unlock()
	runtime_notifyListWait(&c.notify, t) // 等待通知
	c.L.Lock()
}

// Signal wakes one goroutine waiting on c, if there is any.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
//
// Signal() does not affect goroutine scheduling priority; if other goroutines
// are attempting to lock c.L, they may be awoken before a "waiting" goroutine.
func (c *Cond) Signal() {
	c.checker.check()
	runtime_notifyListNotifyOne(&c.notify)
}

// Broadcast wakes all goroutines waiting on c.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
func (c *Cond) Broadcast() {
	c.checker.check()
	runtime_notifyListNotifyAll(&c.notify)
}

type Display struct {
	condition *sync.Cond
	ttype     int // 0 cat 1 dog 2 pig
	times     int
}

func TestSequenceDispaly(t *testing.T) {

	display := Display{}
	var mutex sync.Mutex
	display.condition = sync.NewCond(&mutex)
	display.times = 100
	var wg sync.WaitGroup
	wg.Add(3)
	go display.Cat(&wg)
	go display.Dog(&wg)
	go display.Pig(&wg)
	wg.Wait()
}

func (d *Display) Cat(wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 0; i < d.times; {
		d.condition.L.Lock() //加互斥锁

		// 这里使用for循环判断条件是否满足，如果不满足就阻塞，不会执行for语句块下方的代码，让出了CPU资源
		// 因为我们的逻辑是，唤醒所有等待的goroutine，唤醒的时候并不一定满足条件
		// 如果当前goroutine被唤醒，但是不满足条件，我继续阻塞，直到满足条件的时候，才执行接下来的指令
		for d.ttype != 0 {
			d.condition.Wait()
		}

		// 如果满足条件
		fmt.Println("cat")
		d.ttype = 1 // 将条件变为1 等待Dog协程打印
		i++

		d.condition.L.Unlock()  // 释放锁
		d.condition.Broadcast() //通知其它goroutine 可以唤醒了，不需要阻塞了
	}
}

func (d *Display) Dog(wg *sync.WaitGroup) {
	defer wg.Done()

	for i := 0; i < d.times; {
		d.condition.L.Lock()

		for d.ttype != 1 {
			d.condition.Wait()
		}

		fmt.Println("dog")
		d.ttype = 2
		i++

		d.condition.L.Unlock()
		d.condition.Broadcast()
	}

}

func (d *Display) Pig(wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < d.times; {
		d.condition.L.Lock()

		for d.ttype != 2 {
			d.condition.Wait()
		}

		fmt.Println("pig")
		d.ttype = 0
		i++

		d.condition.L.Unlock()
		d.condition.Broadcast()
	}

}

func TestSequenceDisplayByChanel(t *testing.T) {

	c := make(chan struct{})
	d := make(chan struct{})
	p := make(chan struct{})
	end := make(chan struct{})

	go cat(c, d)
	go dog(d, p)
	go pig(p, c, end)

	c <- struct{}{}
	<-end

}

func cat(start, next chan struct{}) {
	for i := 0; i < 100; i++ {
		<-start // 如果start没有数据则会被阻塞
		fmt.Println("cat")
		next <- struct{}{}
	}
}

func dog(start, next chan struct{}) {
	for i := 0; i < 100; i++ {
		<-start 
		fmt.Println("dog")
		next <- struct{}{}
	}
}

func pig(start, next, end chan struct{}) {
	for i := 0; i < 100; i++ {
		<-start 

		if i == 99 {
			fmt.Println("pig")
			end <- struct{}{}
		} else {
			next <- struct{}{}

		}
	}
}

cond.L.Lock()
for !condition{
    cond.Wait()
}

// 业务逻辑
cond.L.Unlock()