进入频道准备

I am trying to understand channels in Go. I have read that by default sends and receives block until both the sender and receiver are ready. But how do we figure out readyness of sender and receiver.

For example in the following code

package main

import "fmt"

func main() {
    ch := make(chan int)
    ch <- 1

    fmt.Println(<-ch)
}

The program will get stuck on the channel send operation waiting forever for someone to read the value. Even though we have a receive operation in println statement it ends up in a deadlock.

But for the following program

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func () {
        ch <- 1
    }()

    fmt.Println(<-ch)
}

The integer is passed successfully from go routine to main program. What made this program work? Why second works but first do not? Is go routine causing some difference?

Let's step through the first program:

// My notes here
ch := make(chan int)  // make a new int channel
ch <- 1               // block until we can send to that channel
                      // keep blocking
                      // keep blocking
                      // still waiting for a receiver
                      // no reason to stop blocking yet...

// this line is never reached, because it blocks above forever.
fmt.Println(<-ch)

The second program splits the send off into its own line of execution, so now we have:

ch := make(chan int)  // make a new int channel

go func () {          // start a new line of execution
    ch <- 1           // block this second execution thread until we can send to that channel
}()

fmt.Println(<-ch)     // block the main line of execution until we can read from that channel

Since those two lines of execution can work independently, the main line can get down to fmt.Println and try and receive from the channel. The second thread will wait to send until it has.

The go routine absolutely makes a difference. The go routine that writes to the channel will be blocked until your main function is ready to read from the channel in the print statement. Having two concurrent threads, one that reads and one that writes fulfills the readiness on both sides.

In your first example, the single thread gets blocked by the channel write statement and will never reach the channel read.

You need to have a concurrent go routine to read from a channel whenever you write to it. Concurrency goes hand-in-hand with channel usage.