Why does this code generate an error?

The below piece of code generates an error why?

func main() {

    messages := make(chan string)

    messages <- "test" //line 16

	fmt.Println(<-messages)

}

Generates the below error.

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
    /tmp/sandbox994400718/main.go:16 +0x80

A value is sent to the channel, and in the next line it's being received. Technically it should work.

Channels can be buffered or unbuffered. A buffered channel can store a number of items “inside” it, but when you add something to a buffered channel the goroutine adding the item can only continue when another goroutine removes the item. There is no place to “leave” the item, it must be passed directly to the other goroutine, and the first goroutine will wait until another one take the item from it.

This is what is happening in your code. When you create a channel with make, if you don’t specify a capacity as the second argument you get an unbuffered channel. To create a buffered channel pass a second argument to make, e.g.

messages := make(chan string, 1) // could be larger than 1 if you want

This allows the goroutine to add the item (a string in this case) to the channel, where it will be available when another goroutine tries to get an item from the channel in the future, and the original goroutine can then continue processing.

I have learnt a lot about channels now, and now I'm able to answer the question.

In line 16 when the message "test" is sent to the channel by the main thread(goroutine) the execution pauses and the runtime looks for other goroutines which are ready to receive the value from the channel message. Since there are no other channels the runtime raises a panic with the deadlock message. This a classic example for deadlock.

To fix this there are two things that can be done.

1. Use buffered channels as Matt suggested(one of the answers).

2. Else have the statement that sends to channel or receives from channel in a go routine.

   func main() {

    messages := make(chan string)
   
    go func() {
        messages <- "test" //line 16
    }()
    fmt.Println(<-messages)
   

   }

So the essential take aways from this is that,

1. Channels can be used only to communicate between goroutines i.e when you send to channel in one goroutine you can receive it only in another goroutine not the same.

2. When data is sent to a channel in a goroutine the flow/execution of that goroutine is paused until the data is received from the same channel in another goroutine.