“我们最好在解锁条件变量基于的那个互斥锁之后，再去调用它的这两个方法（signal和Broadcast）。这更有利于程序的运行效率” 这个应该如何理解？

我的理解是如果先调用signal方法，然后在unlock解锁，如果在这两个操作中间该线程失去cpu，或者我人为的在siganl和unlock之间调用time.Sleep();在另一个等待线程中即使该等待线程被前者所发出的signal唤醒，但是唤醒的时候同时会去进行lock操作，但是前者的线程中由于失去了cpu，并没有调用unlock，那么这次唤醒不是应该失败了吗，即使前者有得到了cpu去执行了unlcok，但是signal操作具有及时性，等待线程不是应该继续等待下一个signal吗，感觉最后会变成死锁啊

lock.Lock()
for mailbox == 1 {
 sendCond.Wait()
}
mailbox = 1
lock.Unlock()
recvCond.Signal()
如果wait已经解锁lock.Lock()锁住的锁，后面lock.Unlock解锁是什么意思？不会panic。
条件变量这2篇看起来前后理解不到

wait的原理讲解很清晰。

请问老师两个问题：
1. 收信人也修改了mailbox，为什么不用写锁？我试了一下，如果把收信人分成两个goroutine，一个循环2次另一个循环3次，有可能两个收信人先后连续收了信，这样最后一步是发信人发信。recvCond.Signal()只唤醒一个收信人，为什么会有两个收信人先后连续收信呢？我把recvCond改成用写锁就恢复正常了。用写锁是为了演示一下获取写锁的方法么？
package main

import (
    "log"
    "sync"
    "time"
)

func main() {
    var mailbox uint8
    var lock sync.RWMutex
    sendCond := sync.NewCond(&lock)
    recvCond := sync.NewCond(lock.RLocker())

    sign := make(chan struct{}, 3)
    max := 5

    // 发信
    go func(max int) {
        defer func() {
            sign <- struct{}{}
        }()

        for i := 1; i <= max; i++ {
            time.Sleep(time.Millisecond * 500)
            lock.Lock()
            for mailbox == 1 {
                sendCond.Wait()
            }
            log.Printf("sender [%d]: the mail box is empty.", i)
            mailbox = 1
            log.Printf("sender [%d]: the letter has been send.", i)
            lock.Unlock()
            recvCond.Signal()
        }
    }(max)

    // 收信
    go func(max int) {
        defer func() {
            sign <- struct{}{}
        }()
        for j := 1; j <= max; j++ {
            time.Sleep(time.Millisecond * 500)
            lock.RLock()
            for mailbox == 0 {
                recvCond.Wait()
            }
            log.Printf("receiver [%d]: the mail box is full.", j)
            mailbox = 0
            log.Printf("receiver [%d]: the letter has been received.", j)
            lock.RUnlock()
            sendCond.Signal()
        }
    }(2)

    // 收信
    go func(max int) {
        defer func() {
            sign <- struct{}{}
        }()
        for j := 1; j <= max; j++ {
            time.Sleep(time.Millisecond * 500)
            lock.RLock()
            for mailbox == 0 {
                recvCond.Wait()
            }
            log.Printf("receiver [%d]: the mail box is full.", j)
            mailbox = 0
            log.Printf("receiver [%d]: the letter has been received.", j)
            lock.RUnlock()
            sendCond.Signal()
        }
    }(3)

    <-sign
    <-sign
    <-sign

    log.Println(mailbox)
}
2. “当通知被发送的时候，如果没有任何 goroutine 需要被唤醒，那么该通知就会立即失效。”这一点我没有理解。我让收信人启动更晚一点，也就是发信人执行Signal()的时候收信人还没有Wait()，但是依然正常执行了。

send := func(id int, index int) {
        // defer func() {
        //     sign <- struct{}{}
        // }()
        lock.Lock()
        wakeupNum := 0
        log.Printf("wait before wakeupNum: [%d]", wakeupNum)
        for msgbox == 1 {
            fmt.Printf("wait before in for wakeupNum: [%d]", wakeupNum)
            // log.Printf("wait before in for wakeupNum: [%d]", wakeupNum)
            sendCond.Wait()
            // log.Printf("other Broadcast")
            wakeupNum = 1
            log.Printf("wait after wakeupNum: [%d]", wakeupNum)
        }
        log.Printf("sender: id:[%d] index:[%d] msgbox is empty", id, index)
        log.Printf("wakeupNum: [%d]", wakeupNum)
        sendNum = wakeupNum
        msgbox = 1
        log.Printf("sender: id:[%d] index:[%d] mail has been send", id, index)
        lock.Unlock()
        recvCond.Broadcast()
    }
for循环里面的代码被优化了吗。怎么没有执行呢。望老师解惑感谢