Using Go's select Statement

If you are an experience Go developer this will likely all be review, but I wanted to share it since I am working on a more in-depth tutorial that requires a reasonable understanding of channels and Go’s select statement.

Let’s start with the basics - imagine that you have a channel named someChannel and you are waiting on a signal from that channel. In Go we can do this with the following code.

// Waiting for a message from a single channel.
<-someChannel

If we want the value sent over the channel, we can assign it to a variable.

value := <-someChannel

Quite frequently, we will want to tell our program to wait for a message from one of multiple channels. What we basically want is a switch statement that can wait for a message from one of multiple channels.

// This is NOT valid Go code.
switch {
case <-someChannel:
  // ...
case <-someOtherChannel:
  // ...
}

We can do this using the select statement, which looks very similar to the switch statement, but is tailored specifically for waiting for messages from multiple channels.

select {
case <-someChannel:
  // ...
case <-someOtherChannel:
  // ...
}

When we use the select statement, our program will block until one of the channels has a message, at which point the select statement will execute the corresponding case block. We can see a complete example in the following code.

package main

import (
	"fmt"
	"time"
)

func main() {
	chA, chB := make(chan int), make(chan int)

	go func() {
		time.Sleep(1 * time.Second)
		chA <- 2
	}()
	go func() {
		time.Sleep(2 * time.Second)
		chB <- 3
	}()

	select {
	case a := <-chA:
		fmt.Println("A", a)
	case b := <-chB:
		fmt.Println("B", b)
	}
}

In this example we can also see another unique difference between the select statement and the switch statement - the assignment of values to a new variable in a case block. Specifically, if we receive a message from either channel we can assign it to a new variable and use that variable in the case block.

case value := <-someChannel:
  // use value here...

While the code here is fairly simple, especially if one is already familiar with Go’s select statement, it can enable some very powerful patterns in Go programs.