How channel buffers work in golang when used without goroutines (within their scope) vs when they are passed to goroutines?

Issue

I am absolute newbie in Golang. I am learning through Tour of Go and then implementing ideas with my own understanding. I am having problem with goroutines. I made a unbuffered channel , then sent a string to that channel.

func main() {
    p := make(chan string)
    p <- "Hello goroutine"
    fmt.Println(<-p)
}

throws error

fatal error: all goroutines are asleep – deadlock!

I get it, channel is unbuffered. (That’s the reason. Right?).

But when I refactor p <- "Hello goroutine to a goroutine

func main() {
    p := make(chan string)
    go sendHello(p)
    fmt.Println(<-p)
}

func sendHello(p chan string) {
    p <- "Hello goroutine"
}

It works without problem. I read that we do not need to use pointers with maps,slices and channels with most cases to modify the value. Was channel p passed to func sendHello(p chan string) via a copy which had a separate buffer. I still can not get my head around it.

Solution

Keep in mind that a channel has two ends, a sender and a receiver. Your problem is about the order of execution.

In the first example, when you use an unbuffered channel, the channel expects a receiver, while there’s none as of sending Hello goroutine message, and waits until there’s one (this is not the case for a buffered channel as it doesn’t require to wait), and the execution never reaches the next line (i.e. a deadlock).

But in the second example, the receiver is bound to the channel and the groutine is executed after, and both sender and receiver don’t remain in a wait state.

Answered By – Alirus

Answer Checked By – Terry (GoLangFix Volunteer)

Leave a Reply

Your email address will not be published.