select lader en goroutine vente på multiple channel-operationer samtidigt og fortsætter med det, som er klar først. Det er som en switch men for channels — essentielt for at koordinere concurrent-operationer, timeouts og cancellation.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select blokerer, indtil en af dets channel-operationer kan fortsætte, og udfører derefter det case. Hvis flere er klar på én gang, vælger den en tilfældigt (for at forhindre starvation).
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
}
At kombinere en work channel med time.After er den idiomatiske måde at tilføje et timeout på — fortsæt, hvis resultatet ankommer, ellers give op efter en deadline. Dette forhindrer goroutines i at blive blokeret uendeligt.
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
Et default case gør select ikke-blokerende: hvis ingen channel er klar, kører default umiddelbart i stedet for at vente.
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
}
}
}
Mønsteret case <-ctx.Done() lader en goroutine lytte efter cancellation mens arbejde udføres — standardmåden at gøre goroutines stoppable og undgå leaks.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select er et fundamentalt værktøj for Go concurrency — det er sådan goroutines koordinerer multiple channels, hvilket muliggør mønstre, der er essentielle for reelle concurrent-programmer.
Dets vigtigste brugsmåder er kritiske: timeouts (time.After) forhindrer uendelig blokering; ikke-blokerende channel-kontroller (default) forhindrer at blive stukket fast; og især cancellation (<-ctx.Done()) lader goroutines afslutte rent, hvilket er den primære forsvar mod goroutine-leaks.
Uden select kunne du ikke elegant vente på flere channels, implementere deadlines eller gøre goroutines responsive over for shutdown-signaler.
At forstå select (dens blokerings-til-klar-adfærd, tilfældig valg blandt klar cases, default for ikke-blokering, og timeout/cancellation-idiomerne) er essentielt for at skrive robust, leak-fri concurrent Go og er blandt kerneconcurrency-emnerne i sproget.