Select with multiple channels in Go - Step-by-Step Execution

Concept Flow - Select with multiple channels

Start

↓

Wait for any channel

↓

Chan1

↓

Handle

↓

Repeat or Exit

The program waits for messages from multiple channels and handles whichever is ready first, including a default case if none are ready.

Execution Sample

Go

package main
import "fmt"
func main() {
 c1 := make(chan string)
 c2 := make(chan string)
 select {
 case msg1 := <-c1:
  fmt.Println("Received", msg1)
 case msg2 := <-c2:
  fmt.Println("Received", msg2)
 default:
  fmt.Println("No message received")
 } 
}

This code waits to receive from two channels and prints the message received or a default message if none are ready.

Execution Table

Step	Select Case	Channel Ready?	Action Taken	Output
1	case msg1 := <-c1	No	Skipped
2	case msg2 := <-c2	No	Skipped
3	default	N/A	Executed	No message received
4	End	N/A	Program ends

💡 No channels were ready, so default case executed and program ended.

Variable Tracker

Variable	Start	After Select
msg1	undefined	undefined
msg2	undefined	undefined

Key Moments - 2 Insights

Why does the default case run even though channels exist?

Because neither channel had data ready to receive, so select immediately runs the default case as shown in execution_table row 3.

What happens if multiple channels are ready at the same time?

Select picks one at random to execute. This is not shown here but is important to know for concurrency.

Visual Quiz - 3 Questions

Look at the execution table, which step shows the default case running?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Check the 'Action Taken' and 'Output' columns in the execution_table.

At which step does the program decide no channels are ready?

A Step 3

B Step 4

C Step 1

D Step 2

💡 Hint

Look at the 'Channel Ready?' column and when default executes.

If c1 had a message ready, what would change in the execution table?

A Default case would still run

B Step 1 would execute and print the message

C Step 2 would execute instead

D Program would deadlock

💡 Hint

Refer to how select picks the first ready channel case to execute.

Concept Snapshot

select {
 case <-chan1:
  // handle chan1
 case <-chan2:
  // handle chan2
 default:
  // handle no ready channel
}

- Waits for multiple channels
- Executes first ready case
- Default runs if none ready
- Useful for concurrent waits

Full Transcript

This example shows how Go's select statement waits for multiple channels. It checks each channel to see if it has data ready. If none are ready, the default case runs immediately. The execution table shows each step: first checking channel 1, then channel 2, then default. Variables msg1 and msg2 remain undefined because no data was received. Key points include that default runs only if no channels are ready, and if multiple channels are ready, select picks one randomly. The quiz tests understanding of which step runs default and what happens if a channel is ready.