select

Question 1

Basic select

Answer 1

Syntax:

select {
case msg := <-ch1:
    fmt.Println(msg)
case ch2 <- data:
    fmt.Println("sent")
}

Behavior:
* Blocks until one case can proceed
* Random selection if multiple cases ready

Question 2

Non-Blocking select

Answer 2

Using default:

select {
case val := <-ch:
    fmt.Println(val)
default:
    fmt.Println("no value ready")
}

Use Case: Poll channels without blocking

Question 3

Timeout Pattern

Answer 3

With time.After:

select {
case res := <-longOperation():
    fmt.Println(res)
case <-time.After(1 * time.Second):
    fmt.Println("timeout!")
}

Key Point: Creates a temporary channel

Question 4

Empty select

Answer 4

Blocks forever:

select {}  // Equivalent to: for {}

Use Case: Prevent main() from exiting (rare)

Question 5

Priority Selection

Answer 5

Immediate vs Fallback:

select {
case job := <-priorityQueue:
    process(job)
default:
    select {
    case job := <-normalQueue:
        process(job)
    case <-time.After(10 * time.Millisecond):
        fmt.Println("idle")
    }
}

Question 6

Combined with for

Answer 6

Continuous Monitoring:

~~~
for {
select {
case msg := <-msgCh:
handle(msg)
case <-stopCh:
return // Exit loop
}
}```

Question 7

nil Channels

Answer 7

Behavior:
* Sends/receives on nil channels never execute
* Useful for disabling cases dynamically:

var dataCh chan Data  // nil initially

select {
case data := <-dataCh:  // Skipped
    process(data)
case <-time.After(1 * time.Second):
    fmt.Println("no data channel")
}

Question 8

Multiple Actions

Answer 8

Single Case:

select {
case val := <-ch:
    fmt.Println(val)
    fallthrough  // Rarely used!
case <-time.After(0):
    fmt.Println("always runs after first case")
}

Question 9

Common Pitfalls

Answer 9

❌ Forgetting default → deadlock risk
❌ Unbalanced channel operations → leaks
❌ Ignoring ok when checking closed channels

Question 10

Real-World Patterns

Answer 10

1. Fan-in:

select {
case v := <-source1:
    out <- v
case v := <-source2:
    out <- v
}

2. Graceful Shutdown:

select {
case <-workDone:
    fmt.Println("completed")
case <-ctx.Done():
    fmt.Println("cancelled")
}

Question 11

Golden Rules

Answer 11

1. select is Go’s switch for channels
2. Always handle all possible cases
3. Use timeouts to prevent deadlocks
4. nil channels are useful for dynamic control