select Statement & Default Cases

select permite que uma goroutine espere em múltiplas operações de canal ao mesmo tempo.

Adicione default quando precisar de uma sondagem não bloqueante, timeout ou loop apertado com outro trabalho.

Resumo

select bloqueia até que pelo menos um caso possa prosseguir: send, receive, ou default.

Se vários casos estiverem prontos, Go escolhe um pseudo-aleatoriamente.

default é executado imediatamente quando nenhum caso de canal está pronto - nunca o use em um loop de spin sem time.Sleep ou runtime.Gosched.

Timeouts combinam select com time.After ou deadlines de context.Context.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

select {
case msg := <-messages:
    handle(msg)
case err := <-errors:
    log(err)
case <-time.After(5 * time.Second):
    return fmt.Errorf("timeout")
default:
    // não bloqueante: nenhum canal pronto no momento
}

Quando usar isso:

• Multiplexar resultados, erros e sinais de término em um loop.
• Implementar timeouts em torno de receives bloqueantes.
• Desabilitar casos dinamicamente definindo variáveis de canal como nil.
• Evitar loops de busy waiting com default em servidores - use select bloqueante ou goroutines separadas.

Exemplo de Trabalho

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("recebido", v)
            close(quit)
        case <-time.After(1 * time.Second):
            fmt.Println("timeout")
            close(quit)
        case <-quit:
            fmt.Println("encerrando loop")
            return
        }
    }
}

O que isso demonstra:

• Trabalho e timeout competem em um único select.
• quit canal quebra o loop após o primeiro resultado.
• ch com buffer permite que o remetente conclua sem um receptor concorrente no momento do envio (ainda funciona sem buffer com goroutine pareada).
• Código de produção prefere context.WithTimeout em vez de time.After bruto em loops de longa duração (GC de timer - veja Gotchas).

Mergulho Profundo

Como Funciona

• select avalia operações de canal como sends/receives independentes, mas espera pelo primeiro caso pronto.
• Todas as expressões de canal são avaliadas uma vez na entrada do select (incluindo expressões de valor de send).
• default contorna o bloqueio quando nenhum caso está imediatamente pronto.
• Definir o canal de um caso como nil desabilita esse branch até que seja reatribuído.
• for { select { ... } } é o loop de eventos idiomático para goroutines orientadas a canal.

Casos de select em um Relance

Padrões de Timeout

Notas Go

// Desabilita um caso por canal nil
var ch chan int // nil
select {
case v := <-ch: // nunca selecionado
    _ = v
default:
    fmt.Println("ch desabilitado")
}
 
// Send não bloqueante
select {
case out <- item:
default:
    return ErrQueueFull
}

Gotchas

• time.After em loops apertados - Cria timers que o GC pode demorar para liberar. Correção: time.NewTimer, reinicie cuidadosamente, ou context.
• Spin de busy waiting com default - Consome CPU. Correção: bloqueie em canais ou durma/ceda entre as sondagens.
• Assumir prioridade do select - Casos prontos são escolhidos aleatoriamente. Correção: loops separados ou manipulação serializada se a ordem importar.
• Lado de send avaliado antecipadamente - case ch <- expensive() executa expensive() antes de esperar. Correção: calcule antes do select ou use uma goroutine interna.
• break sai apenas do select - Não do for circundante. Correção: use rótulos ou return para sair do loop.

Alternativas

FAQs

Relacionado

• Fundamentos de Concorrência - exemplo introdutório de select
• Canais: Regras de Buffer, Não Buffer e Fechamento - semântica de canal
• Concorrência em Go: Goroutines e Canais Primeiro - multiplexação em CSP
• Goroutines: Custo de Criação e Visão Geral do Agendamento - loops de eventos em escala
• Fundamentos de Concorrência: Melhores Práticas - hábitos de timeout e loop

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos de placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).