select Statement & Default Cases

select permite que una goroutine espere en múltiples operaciones de canal a la vez.

Agrega default cuando necesites una sonda no bloqueante, un tiempo de espera o un bucle ajustado con otro trabajo.

Resumen

select se bloquea hasta que al menos un caso pueda proceder: envío, recepción o default.

Si varios casos están listos, Go elige uno de forma pseudoaleatoria.

default se ejecuta inmediatamente cuando ningún caso de canal está listo; nunca lo uses en un bucle de sondeo sin time.Sleep o runtime.Gosched.

Los tiempos de espera combinan select con los plazos de time.After o context.Context.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

select {
case msg := <-messages:
    handle(msg)
case err := <-errors:
    log(err)
case <-time.After(5 * time.Second):
    return fmt.Errorf("timeout")
default:
    // no bloqueante: ningún canal listo en este momento
}

Cuándo usar esto:

• Multiplexar resultados, errores y señales de finalización en un solo bucle.
• Implementar tiempos de espera alrededor de recepciones bloqueantes.
• Deshabilitar casos dinámicamente estableciendo variables de canal en nil.
• Evitar bucles de sondeo default en servidores - usar select bloqueante o goroutines separadas.

Ejemplo de Trabajo

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string, 1)
    quit := make(chan struct{})
 
    go func() {
        time.Sleep(200 * time.Millisecond)
        ch <- "result"
    }()
 
    for {
        select {
        case v := <-ch:
            fmt.Println("recibido", v)
            close(quit)
        case <-time.After(1 * time.Second):
            fmt.Println("tiempo de espera agotado")
            close(quit)
        case <-quit:
            fmt.Println("cerrando bucle")
            return
        }
    }
}

Lo que esto demuestra:

• El trabajo y el tiempo de espera compiten en un solo select.
• quit canal rompe el bucle después del primer resultado.
• ch con búfer permite que el remitente complete sin un receptor concurrente en el instante del envío (aún funciona sin búfer con goroutine emparejada).
• El código de producción prefiere context.WithTimeout sobre time.After crudo en bucles de larga duración (GC del temporizador - ver Gotchas).

Inmersión Profunda

Cómo Funciona

• select evalúa las operaciones de canal como envíos/recepciones independientes, pero espera en el primer caso listo.
• Todas las expresiones de canal se evalúan una vez al entrar en select (incluidas las expresiones de valor de envío).
• default evita el bloqueo cuando ningún caso está listo inmediatamente.
• Establecer el canal de un caso en nil deshabilita esa rama hasta que se reasigna.
• for { select { ... } } es el bucle de eventos idiomático para goroutines impulsadas por canales.

Casos de select de un Vistazo

Patrones de Tiempo de Espera

Notas de Go

// Deshabilita un caso mediante un canal nil
var ch chan int // nil
select {
case v := <-ch: // nunca seleccionado
    _ = v
default:
    fmt.Println("ch deshabilitado")
}
 
// Envío no bloqueante
select {
case out <- item:
default:
    return ErrQueueFull
}

Gotchas

• time.After en bucles ajustados - Crea temporizadores que el GC puede tardar en liberar. Solución: time.NewTimer, restablecer con cuidado o context.
• Sondeo ocupado default - Quema CPU. Solución: bloquear en canales o dormir/ceder entre sondeos.
• Asumir prioridad de select - Los casos listos se eligen al azar. Solución: bucles separados o manejo serializado si el orden importa.
• Lado de envío evaluado rápidamente - case ch <- expensive() ejecuta expensive() antes de esperar. Solución: calcular antes de select o usar una goroutine interna.
• break solo sale de select - No del for circundante. Solución: usar etiquetas o return para salir del bucle.

Alternativas

Preguntas Frecuentes

Relacionado

• Fundamentos de Concurrencia - ejemplo introductorio de select
• Canales: Reglas de Búfer, Sin Búfer y Cierre - semántica de canales
• Concurrencia en Go: Primero Goroutines y Canales - multiplexación en CSP
• Goroutines: Costo de Creación y Visión General de la Planificación - bucles de eventos a escala
• Fundamentos de Concurrencia: Mejores Prácticas - hábitos de tiempo de espera y bucle

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC predeterminado Green Tea, go fix modernizers - verificar parche en la compilación), chi (última versión - verificar en la compilación), gin (última versión - verificar en la compilación), echo (última versión - verificar en la compilación), google.golang.org/grpc (última versión - verificar en la compilación), sigs.k8s.io/controller-runtime (última versión - verificar en la compilación), kubebuilder (última versión - verificar en la compilación), tinygo (última versión - verificar objetivos de placa en la compilación), wazero (última versión - verificar en la compilación) y golangci-lint (última versión - verificar conjunto de linters en la compilación).