select laat een goroutine op meerdere channel-operaties tegelijk wachten en gaat verder met degene die het eerst klaar is. Het is als een switch maar voor channels — essentieel voor het coördineren van gelijktijdige operaties, timeouts en cancellation.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select blokkeert totdat één van zijn channel-operaties kan plaatsvinden, en voert dan dat geval uit. Als meerdere tegelijk klaar zijn, kiest het willekeurig één (om hongersnood te voorkomen).
select {
case result := <-workCh:
fmt.Println("got result:", result)
case <-time.After(2 * time.Second): // fires after 2 seconds
fmt.Println("timed out") // don't wait forever
}
Een work-channel koppelen met time.After is de idiomatische manier om een timeout toe te voegen — ga verder als het resultaat aankomt, anders geef het op na een deadline. Dit voorkomt dat goroutines oneindig lang blokkeren.
select {
case msg := <-ch:
fmt.Println("received:", msg)
default:
fmt.Println("no message ready") // runs immediately if no case is ready
}
// with a default case, select NEVER blocks — it's a non-blocking check
Een default geval maakt select non-blocking: als geen channel klaar is, voert default onmiddellijk uit in plaats van te wachten.
func worker(ctx context.Context, jobs <-chan int) {
for {
select {
case job := <-jobs:
process(job)
case <-ctx.Done(): // context cancelled or timed out
fmt.Println("shutting down:", ctx.Err())
return // clean exit — prevents goroutine leak
}
}
}
Het case <-ctx.Done() patroon laat een goroutine naar cancellation luisteren terwijl het werk doet — de standaardmanier om goroutines stoppabel te maken en leaks te voorkomen.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select is een fundamenteel tool voor Go-concurrency — het is hoe goroutines meerdere channels coördineren, waardoor patronen mogelijk worden die essentieel zijn voor echte gelijktijdige programma's.
De belangrijkste toepassingen zijn kritiek: timeouts (time.After) voorkomen oneindig blokkeren; non-blocking channel-controles (default) vermijden vast te lopen; en vooral cancellation (<-ctx.Done()) laat goroutines schoon afsluiten, wat de primaire verdediging tegen goroutine-leaks is.
Zonder select kon je niet elegant op meerdere channels wachten, deadlines implementeren of goroutines responsief maken voor shutdown-signalen.
Het begrijpen van select (het blokkeer-totdat-klaar gedrag, willekeurige keuze tussen klare gevallen, de default voor non-blocking, en de timeout/cancellation-idiomen) is essentieel voor het schrijven van robuuste, leak-vrije gelijktijdige Go en behoort tot de kernonderwerpen van concurrency in de taal.