当我在Go中的select语句之外移动条件时，为什么会发生这种死锁

I need a non blocking channel with dynamic buffer for a project so I wrote this code.

Here is the type declaration:

//receiver is the receiver of the non blocking channel
type receiver struct {
    Chan  <-chan string
    list  *[]string
    mutex sync.RWMutex
}

//Clear sets the buffer to 0 elements
func (r *receiver) Clear() {
    r.mutex.Lock()
    *r.list = (*r.list)[:0]
    r.mutex.Unlock()
    //Discards residual content
    if len(r.Chan) == 1 {
        <-r.Chan
    }
}

Constructor:

//NewNonBlockingChannel returns the receiver & sender of a non blocking channel
func NewNonBlockingChannel() (*receiver, chan<- string) {
    //Creates the send and receiver channels and the buffer
    send := make(chan string)
    recv := make(chan string, 1)
    list := make([]string, 0, 20)

    r := &receiver{Chan: recv, list: &list}

    go func() {

        for {
            //When the receiver is empty sends the next element from the buffer
            if len(recv) == 0 && len(list) > 0 {
                r.mutex.Lock()
                recv <- list[len(list)-1]
                list = list[:len(list)-1]
                r.mutex.Unlock()
            }

            select {
            //Adds the incoming elements to the buffer
            case s := <-send:
                r.mutex.Lock()
                list = append(list, s)
                r.mutex.Unlock()
                //default:

            }
        }
    }()

    return r, send
}

And the toy test in the main:

func main() {
    recv, sender := NewNonBlockingChannel()

    //send data to the channel
    go func() {
        for i := 0; i < 5; i++ {
            sender <- "Hi"
        }
        time.Sleep(time.Second)
        for i := 0; i < 5; i++ {
            sender <- "Bye"
        }
    }()
    time.Sleep(time.Millisecond * 70) //waits to receive every "Hi"
    recv.Clear()
    for data := range recv.Chan {
        println(data)
    }

}

When I tested it and a deadlock happened in the select statement when I receive from the sender "case s := <-send:" but when I move the conditional block which sends the next buffered string into the select statement everything works perfectly:

go func() {

    for {
        select {
        //Adds the incoming elements to the buffer
        case s := <-send:
            r.mutex.Lock()
            list = append(list, s)
            r.mutex.Unlock()
        default:
            //When the receiver is empty sends the next element from the buffer
            if len(recv) == 0 && len(list) > 0 {
                r.mutex.Lock()
                recv <- list[len(list)-1]
                list = list[:len(list)-1]
                r.mutex.Unlock()
            }
        }
    }
}()

I'd like to know why.

Imagine this scenario for example:

five "bye" has been send by the main, two of them has been print by

for data := range recv.Chan {
      println(data)
}

three has been left in list (this is because three times enter for loop, the condition len(recv) == 0 && len(list) > 0 is false, so it just meet the case s := <-send, and do list = append(list, s) three times)

and the goroutine started by NewNonBlockingChannel is waiting on the statment s := <-send. no more staff to be receive, so it will wait forever

when you move the code

if len(recv) == 0 && len(list) > 0 {
    r.mutex.Lock()
    recv <- list[len(list)-1]
    list = list[:len(list)-1]
    r.mutex.Unlock()
}

into the select, things are different:

the waiting gorountine will wake up, and the condition if len(recv) == 0 && len(list) > 0 is ture just in time. things goes well.