select permet à une goroutine d'attendre plusieurs opérations sur canaux simultanément, en procédant avec celle qui est prête en premier. C'est comme un switch mais pour les canaux — essentiel pour coordonner les opérations concurrentes, les délais d'attente et l'annulation.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select se bloque jusqu'à ce que l'une de ses opérations sur canal puisse procéder, puis exécute ce cas. Si plusieurs sont prêtes à la fois, il en choisit une aléatoirement (prévenant la famine).
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
}
Associer un canal de travail avec time.After est la manière idiomatique d'ajouter un délai d'attente — procéder si le résultat arrive, sinon abandonner après une limite. Cela empêche les goroutines de se bloquer indéfiniment.
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
Un cas default rend select non-bloquant : si aucun canal n'est prêt, default s'exécute immédiatement au lieu d'attendre.
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
}
}
}
Le motif case <-ctx.Done() permet à une goroutine d'écouter une annulation tout en effectuant un travail — la manière standard de rendre les goroutines arrêtables et d'éviter les fuites.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select est un outil fondamental pour la concurrence en Go — c'est comment les goroutines coordonnent plusieurs canaux, activant des motifs essentiels pour les vrais programmes concurrents.
Ses usages clés sont critiques : les délais d'attente (time.After) préviennent les blocages indéfinis ; les vérifications non-bloquantes de canaux (default) évitent de rester bloqué ; et surtout l'annulation (<-ctx.Done()) permet aux goroutines de quitter proprement, ce qui est la défense principale contre les fuites de goroutines.
Sans select, vous ne pourriez pas attendre élégamment plusieurs canaux, implémenter des délais, ou rendre les goroutines réactives aux signaux d'arrêt.
Comprendre select (son comportement de blocage jusqu'à prêt, le choix aléatoire parmi les cas prêts, le default pour non-bloquant, et les idiomes de délai d'attente/annulation) est essentiel pour écrire du Go concurrent robuste et sans fuites, et fait partie des sujets de concurrence essentiels du langage.