Why is the output order of Go's unbuffered channels non-deterministic?

Golang channel output order: A deeper dive

Understanding the order in which messages are received from a channel can be a bit tricky in Go. Let's dive into the code you provided:

func main() {
  messages := make(chan string)
  go func() { messages <- "hello" }()
  go func() { messages <- "ping" }()
  msg := <-messages
  msg2 := <-messages
  fmt.Println(msg)
  fmt.Println(msg2)
}

The following explanation addresses your concerns and provides a clearer understanding of what's happening:

Firstly, it's important to understand that blocking operations, such as sending or receiving from unbuffered channels, do not guarantee an ordering. In Go, goroutine execution is concurrent, and there is no defined order for goroutine execution by default.

When the first goroutine attempts to send "hello" to the channel, if no receiver is currently waiting, the goroutine is blocked. Similarly, when the second goroutine attempts to send "ping," it also gets blocked.

Now, when the msg := <-messages statement is reached, the program will arbitrarily unblock one of the blocked goroutines. The message sent by that unblocked goroutine will be received into msg.

The same process happens for msg2 := <-messages. Another goroutine will be unblocked, and the message sent by that goroutine will be received into msg2.

The order in which goroutines get unblocked and transmit their messages into messages is not deterministic. This is why you consistently see "ping" printed before "hello," even though your assumption was that the routines should have been executed alternatively.

To confirm this, you can try adding print statements to the goroutines:

func main() {
  messages := make(chan string)
  go func() {
    fmt.Println("Sending 'hello'")
    messages <- "hello"
    fmt.Println("Sent 'hello'")
  }()
  go func() {
    fmt.Println("Sending 'ping'")
    messages <- "ping"
    fmt.Println("Sent 'ping'")
  }()
  msg := <-messages
  msg2 := <-messages
  fmt.Println(msg)
  fmt.Println(msg2)
}

Upon executing the code several times, you will notice that the order of print statements from the goroutines may vary. This further demonstrates the non-deterministic nature of goroutine execution.

To summarize, the order of output from a channel is not guaranteed in unbuffered channels, and it depends on the order in which the corresponding goroutines are unblocked.

The above is the detailed content of Why is the output order of Go's unbuffered channels non-deterministic?. For more information, please follow other related articles on the PHP Chinese website!