`select` waits on multiple channel operations, executing the one that's ready first. It's the foundation of timeouts, fan-in, fan-out, and cancellation in Go. ## The basic shape ```go select { case v := <-ch1: fmt.Println("from ch1:", v) case v := <-ch2: fmt.Println("from ch2:", v) case ch3 <- 42: fmt.Println("sent on ch3") } ``` Each `case` is a channel operation (send or receive). `select` blocks until ANY case is ready. If multiple are ready, it picks one at random. ## Timeouts The most common select pattern: bounded waiting. ```go select { case v := <-ch: fmt.Println("got", v) case <-time.After(time.Second): fmt.Println("timed out") } ``` `time.After(d)` returns a channel that fires after duration `d`. If nothing arrives on `ch` within a second, the timeout case wins. ## Default — non-blocking Adding `default` makes select non-blocking: ```go select { case v := <-ch: fmt.Println("got", v) default: fmt.Println("nothing waiting") } ``` The default runs immediately if no other case is ready. Useful for periodic polling without blocking. ## Fan-in pattern Merge multiple channels into one: ```go func merge(a, b <-chan int) <-chan int { out := make(chan int) go func() { defer close(out) for { if a == nil && b == nil { return } select { case v, ok := <-a: if !ok { a = nil; continue } // disable this case out <- v case v, ok := <-b: if !ok { b = nil; continue } out <- v } } }() return out } ``` Setting a channel to `nil` disables its case in the select — a common idiom for managing closed channels. ## Cancellation with context In idiomatic modern Go, cancellation flows through `context.Context`: ```go func work(ctx context.Context) { for { select { case <-ctx.Done(): fmt.Println("cancelled:", ctx.Err()) return case <-time.After(time.Second): doStep() } } } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() work(ctx) ``` Every long-running goroutine should accept a context and check `ctx.Done()` for cancellation. ## Common mistakes - **Forgetting to close channels** — receivers blocking on a closed-but-never-signaled channel leak. - **Selecting without a timeout** — production code should usually have an escape hatch. - **Sending on a closed channel** — panics. The sender should always own closing. - **Goroutines that never check for cancellation** — leak when the caller stops needing them.

Go Intermediate

Curriculum