How to explain channel block mechanism to golang beginners?

I'm a golang beginner and I've encountered some trouble when learning channel and go routine. One of my stuck point is how golang channel block mechanism works. In golang tour, it says By default, sends and receives block until the other side is ready. I did some experiments with my understanding, and met the result, fatal error: all goroutines are asleep - deadlock!. This hints didn't really give me much knowledge about how the error happens. I've googled it, but almost every article I got is about the deep mechanism of channel, or it assumes the reader understanding the single word block already gave out all the information.

But as a beginner I have many doubts, like:

• Can same go-routine execute channel read operation after it writes to the channel?
• If a channel blocked, can other go-routine still send message to it?
• If a go-routine tries to send message to a blocked channel, what will happen? Will it throw an error, or nothing happened, or?

Below is one of my test which confuses me. (According to my knowledge, main func is a go-routine and I think it's the same one across its execution)

package main

import "time"

func chanWrite(s string, ch chan string) {
	ch <- s
	println("write", s)
}

func chanRead(ch chan string) {
	println("read", <- ch)
}

// main func 1
func main() {
	ch := make(chan string)
	go chanWrite("A", ch)
	time.Sleep(time.Second)
}

// main func 1 didn't throw error


// main func 2(modify main func 1 and then execute it)
func main() {
	ch := make(chan string)
	chanWrite("A", ch)
	time.Sleep(time.Second)
}
// main func 2 throw error: "fatal error: all goroutines are asleep - deadlock!"

What I saw in this test is in some condition, when I wrote things to the channel without reading it, I got fatal error, and sometimes nothing happened. (such like in main func 1).

So, can somebody explain how channel block works in a simple and inspiring way so that golang beginners can understand it easily?

A goroutine can block waiting for a channel to be ready for send or receive, but the channel itself is never in a "blocked" state.

The first program does not panic because the main function executes to the end and terminates the program.

> Can same go-routine execute channel read operation after it writes to the channel?

No, if the channel is unbuffered (the default). For an unbuffered channel, a sending goroutine blocks until a receiving goroutine is ready.

A single goroutine cannot execute send and receive at the same time. If there's only one goroutine sending to the channel, the goroutine blocks forever.

> If a channel blocked, can other go-routine still send message to it?

A goroutine can send a value to a channel at any time before the channel is closed. A goroutine can block waiting for the channel to be ready for send.

> If go-routine trys to send message to a blocked channel, what will happened? Will it through an error, or nothing happened, or?

A goroutine can block waiting for the channel to be ready. The channel itself is not in a blocked state.

A channel does not "block". A read or write operation on a channel may block.

For an unbuffered channel (which is what you have above): a write operation will block the writing goroutine until another goroutine is ready to read from that channel. When the reading goroutine is ready to read (i.e. executes <-ch), then the write and read take place, and both goroutines continue running.

For a buffered channel: a write will not block as long as the channel buffer is not full. Similarly, a read will not block if there is something to read from the channel.

As for your questions:

1. If the channel in question is unbuffered, the write operation will block, because a write operation can continue only if another goroutine is reading from the channel. So the goroutine will not progress to read from the channel. If this is a buffered channel and if the channel is not full, the same goroutine may write to the channel and read from it.
2. If a goroutine is waiting to write to a channel, and another goroutine comes to write to it, it will block as well until another goroutine reads fro the channel.
3. If a goroutine tries to write to a channel that is full, it will block until another goroutine can read from the channel.