select permite que una goroutine espere en múltiples operaciones de canal simultáneamente, continuando con la que esté lista primero. Es como un switch pero para canales — esencial para coordinar operaciones concurrentes, timeouts y cancelación.
{
msg1 := <-ch1:
fmt.Println(, msg1)
msg2 := <-ch2:
fmt.Println(, msg2)
ch3 <- :
fmt.Println()
}
select se bloquea hasta que una de sus operaciones de canal pueda proceder, luego ejecuta ese case. Si varios están listos a la vez, elige uno al azar (previniendo inanición).
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
}
Emparejar un canal de trabajo con time.After es la forma idiomática de añadir un timeout — proceder si el resultado llega, de lo contrario rendirse después de un plazo. Esto previene que las goroutines se bloqueen 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
Un case default hace que select sea no-bloqueante: si ningún canal está listo, default se ejecuta inmediatamente en lugar de esperar.
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
}
}
}
El patrón case <-ctx.Done() permite que una goroutine escuche cancelación mientras trabaja — la forma estándar de hacer las goroutines detenibles y evitar fugas.
for {
select {
case data := <-dataCh: ...
case <-quit: return
}
}
select es una herramienta fundamental para concurrencia en Go — es cómo las goroutines coordinan múltiples canales, habilitando patrones que son esenciales para programas concurrentes reales.
Sus usos clave son críticos: timeouts (time.After) previenen bloqueo indefinido; non-blocking en chequeos de canal (default) evitan quedarse atrapado; y especialmente cancelación (<-ctx.Done()) permite que las goroutines salgan limpiamente, que es la defensa principal contra fugas de goroutines.
Sin select, no podrías esperar elegantemente en varios canales, implementar plazos, o hacer que las goroutines sean responsivas a señales de apagado.
Entender select (su comportamiento de bloqueo-hasta-listo, elección aleatoria entre cases listos, el default para no-bloqueante, y los idiomas de timeout/cancelación) es esencial para escribir Go concurrente robusto y sin fugas, y está entre los temas centrales de concurrencia del lenguaje.
Una biblioteca de preguntas de entrevista de IT con respuestas detalladas — de Junior a Senior.
Donar