Select with multiple channels in Go - Mini Project: Build & Apply

Select with multiple channels

📖 Scenario: You are building a simple program that listens to two different message channels. Each channel sends a message at different times. You want to print the message as soon as it arrives from either channel.

🎯 Goal: Create two channels that send messages, then use a select statement to wait for messages from both channels and print them as they arrive.

📋 What You'll Learn

Create two channels called chan1 and chan2 of type chan string

Create a variable called done of type chan bool to signal when to stop

Use a select statement inside a for loop to receive messages from chan1 and chan2

Print the message received from either channel with fmt.Println

Stop the loop after receiving 2 messages total and send true to done

💡 Why This Matters

🌍 Real World

Listening to multiple data sources or events at the same time is common in real-world programs like servers, chat apps, or sensors.

💼 Career

Understanding how to use Go channels and select statements is important for writing concurrent programs and working with real-time data streams.

1

Create two string channels

Create two channels called chan1 and chan2 of type chan string.

Go

# Create two channels called chan1 and chan2 of type chan string
// Your code here

Hint

Use make(chan string) to create a channel of strings.

2

Create a done channel to signal completion

Add a channel called done of type chan bool to signal when to stop the program.

Go

package main

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)
    // Create a done channel of type chan bool
    // Your code here
}

Hint

Use make(chan bool) to create the done channel.

3

Use select to receive messages from both channels

Write a for loop with a select statement to receive messages from chan1 and chan2. Use variables msg1 and msg2 to receive messages. Count the total messages received in a variable called count.

Go

package main

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)
    done := make(chan bool, 1)

    // Use a for loop with select to receive messages from chan1 and chan2
    // Your code here
}

Hint

Use select inside a for loop to wait for messages from both channels.

4

Print messages and stop after two messages

Print the messages received from chan1 and chan2 using fmt.Println. Stop the loop after receiving 2 messages and send true to done. Also, add a line to receive from done to prevent the program from exiting early.

Go

package main

import "fmt"

func main() {
    chan1 := make(chan string)
    chan2 := make(chan string)
    done := make(chan bool, 1)

    count := 0

    go func() {
        chan1 <- "Message from chan1"
    }()

    go func() {
        chan2 <- "Message from chan2"
    }()

    for {
        select {
        case msg1 := <-chan1:
            fmt.Println(msg1)
            count++
        case msg2 := <-chan2:
            fmt.Println(msg2)
            count++
        }
        if count == 2 {
            done <- true
            break
        }
    }

    // Wait for done signal to prevent program exit
    // Your code here
}

Hint

Use <-done to wait for the done signal before exiting.

Practice

1.

What does the select statement do when used with multiple channels in Go?

easy

A. It waits until one of the channels is ready to send or receive and executes that case.

B. It executes all channel operations simultaneously regardless of readiness.

C. It blocks forever until all channels are ready at the same time.

D. It randomly picks a channel to operate on without checking readiness.

Solution

1. Step 1: Understand select behavior

   The select statement waits for one of its channel cases to be ready.

2. Step 2: Identify how select chooses a case

   It picks one of the channels that is ready to send or receive and runs that case.

3. Final Answer:

   It waits until one of the channels is ready to send or receive and executes that case. -> Option A

4. Quick Check:

   Select waits for ready channel = A [OK]

Hint: Select picks the first ready channel to act on [OK]

Common Mistakes:

• Thinking select runs all channels at once
• Believing select waits for all channels simultaneously
• Assuming select picks channels randomly without readiness check

2.

Which of the following is the correct syntax to use select with two channels ch1 and ch2 for receiving values?

?

easy

A. select {
case val = <-ch1:
fmt.Println(val)
case val = <-ch2:
fmt.Println(val)
}

B. select {
case <-ch1:
fmt.Println(val)
case <-ch2:
fmt.Println(val)
}

C. select {
case val := ch1:
fmt.Println(val)
case val := ch2:
fmt.Println(val)
}

D. select {
case val := <-ch1:
fmt.Println(val)
case val := <-ch2:
fmt.Println(val)
}

Solution

1. Step 1: Check channel receive syntax

   Receiving from a channel uses val := <-ch to assign the received value.

2. Step 2: Verify select case syntax

   Each case must have a receive operation with assignment like val := <-ch1.

3. Final Answer:

   select { case val := <-ch1: fmt.Println(val) case val := <-ch2: fmt.Println(val) } -> Option D

4. Quick Check:

   Correct receive syntax uses := <-channel [OK]

Hint: Use := <-channel to receive inside select case [OK]

Common Mistakes:

• Using = instead of := for assignment
• Omitting the <- operator for receiving
• Trying to assign channel itself instead of received value

3.

What will be the output of the following Go program?

package main
import (
    "fmt"
    "time"
)
func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch1 <- "hello"
    }()
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch2 <- "world"
    }()
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

medium

A. hello

B. world

C. hello
world

D. No output (deadlock)

Solution

1. Step 1: Analyze goroutine sleep durations

   The goroutine sending to ch2 sleeps 50ms, and ch1 sleeps 100ms.

2. Step 2: Determine which channel is ready first

   Since ch2 sends first, the select will receive from ch2 and print "world".

3. Final Answer:

   world -> Option B

4. Quick Check:

   Channel with shorter sleep sends first = world [OK]

Hint: Select picks channel ready first (shorter sleep) [OK]

Common Mistakes:

• Assuming ch1 sends first because it is listed first
• Expecting both messages to print
• Thinking select waits for all channels

4.

Identify the error in this Go code using select with multiple channels:

package main
import "fmt"
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    select {
    case val := <-ch1:
        fmt.Println(val)
    case val := <-ch2:
        fmt.Println(val)
    }
}

medium

A. Channels must be buffered to use select.

B. The select statement syntax is invalid without a loop.

C. The program will deadlock because channels are never written to.

D. The default case is not allowed in select statements.

Solution

1. Step 1: Analyze channel creation

   Channels ch1 and ch2 are unbuffered with no goroutines to send values.

2. Step 2: Select behavior without senders

   The select blocks forever since no channels become ready, causing a deadlock.

3. Final Answer:

   The program will deadlock because channels are never written to. -> Option C

4. Quick Check:

   No senders + no default = deadlock [OK]

Hint: No senders and no default causes deadlock [OK]

Common Mistakes:

• Thinking channels must be buffered to use select
• Believing select syntax is invalid without a loop
• Assuming a default case is required or invalid

5.

You want to write a Go function that waits on two channels chA and chB and returns the first value received from either. If neither channel is ready immediately, it should return "timeout" after 100 milliseconds. Which select structure correctly implements this?

hard

A. select {
case val := <-chA:
return val
case val := <-chB:
return val
case <-time.After(100 * time.Millisecond):
return "timeout"
}

B. select {
case val := <-chA:
return val
case val := <-chB:
return val
default:
time.Sleep(100 * time.Millisecond)
return "timeout"
}

C. select {
case val := <-chA:
return val
case val := <-chB:
return val
case <-time.Tick(100 * time.Millisecond):
return "timeout"
}

D. select {
case val := <-chA:
return val
case val := <-chB:
return val
case <-time.After(100):
return "timeout"
}

Solution

1. Step 1: Use time.After for timeout

   The time.After function returns a channel that sends a value after the specified duration, perfect for timeout.

2. Step 2: Check select cases

   Cases for receiving from chA and chB return the first received value; the timeout case returns "timeout" after 100ms.

3. Step 3: Validate other options

   select { case val := <-chA: return val case val := <-chB: return val default: time.Sleep(100 * time.Millisecond) return "timeout" } uses default with sleep which blocks select; select { case val := <-chA: return val case val := <-chB: return val case <-time.Tick(100 * time.Millisecond): return "timeout" } uses time.Tick which repeats; select { case val := <-chA: return val case val := <-chB: return val case <-time.After(100): return "timeout" } uses incorrect duration type.

4. Final Answer:

   select { case val := <-chA: return val case val := <-chB: return val case <-time.After(100 * time.Millisecond): return "timeout" } -> Option A

5. Quick Check:

   Use time.After channel for timeout in select [OK]

Hint: Use time.After channel for timeout in select [OK]

Common Mistakes:

• Using default with sleep instead of time.After
• Using time.Tick which repeats instead of time.After
• Passing wrong duration type to time.After