select permite que uma goroutine aguarde múltiplas operações em canais simultaneamente, prosseguindo com aquela que estiver pronta primeiro. É como um switch mas para canais — essencial para coordenar operações concorrentes, timeouts e cancelamento.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select bloqueia até que uma de suas operações de canal possa prosseguir, então executa esse case. Se vários estão prontos ao mesmo tempo, escolhe um aleatoriamente (prevenindo inanição).
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
}
Acoplar um canal de trabalho com time.After é a forma idiomática de adicionar um timeout — proceda se o resultado chegar, caso contrário desista após um prazo. Isso previne que goroutines bloqueiem indefinidamente.
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
Um case default torna select não-bloqueante: se nenhum canal está pronto, default é executado imediatamente em vez de aguardar.
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
}
}
}
O padrão case <-ctx.Done() permite que uma goroutine ouça um cancelamento enquanto trabalha — a forma padrão de tornar goroutines canceláveis e evitar vazamentos.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select é uma ferramenta fundamental para concorrência em Go — é como goroutines coordenam múltiplos canais, habilitando padrões que são essenciais para programas concorrentes reais.
Seus usos chave são críticos: timeouts (time.After) previnem bloqueio indefinido; verificações de canais não-bloqueantes (default) evitam ficar preso; e especialmente cancelamento (<-ctx.Done()) permite que goroutines saiam de forma limpa, que é a defesa principal contra vazamentos de goroutines.
Sem select, você não conseguiria aguardar elegantemente vários canais, implementar prazos ou tornar goroutines responsivas a sinais de desligamento.
Entender select (seu comportamento de bloqueio até estar pronto, escolha aleatória entre cases prontos, o default para não-bloqueante, e os idiomas de timeout/cancelamento) é essencial para escrever Go concorrente robusto e sem vazamentos e está entre os tópicos centrais de concorrência na linguagem.