Go Academy · Aula

Timeouts e temporizadores

Use time.After e time.Tick com select

Timeouts e temporizadores é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que os tempos limite são importantes

Sem tempos limite, uma gorrotina que aguarda um canal lento pode bloquear para sempre. O pacote time fornece primitivas para adicionar controle baseado em tempo às operações de canal.

time.After para um tempo limite de uso único

time.After(d) retorna um canal que recebe um valor após a duração d. Use-o em um caso de seleção para interromper uma espera.

select {
case res := <-ch:
    fmt.Println(res)
case <-time.After(2 * time.Second):
    fmt.Println("timed out")
}

Tempos limite repetidos com time.NewTimer

Para temporizadores reutilizáveis, use time.NewTimer e chame Reset após cada uso. Chame Stop para evitar o vazamento da gorrotina do temporizador.

timer := time.NewTimer(5 * time.Second)
defer timer.Stop()
select {
case <-timer.C:
    fmt.Println("timer fired")
}

time.Tick versus time.NewTicker

time.Tick é conveniente, mas vaza o temporizador subjacente — prefira time.NewTicker para poder chamar Stop() e liberar os recursos.

ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()
for range ticker.C {
    fmt.Println("tick")
}

Temporizador periódico em um laço

Combine um temporizador periódico com um canal de conclusão para executar tarefas periódicas que sejam interrompidas de forma limpa.

ticker := time.NewTicker(time.Second)
done := make(chan struct{})
go func() {
    for {
        select {
        case <-ticker.C:
            doWork()
        case <-done:
            ticker.Stop()
            return
        }
    }
}()

Vazamento de time.After

time.After cria um novo temporizador a cada chamada, e o temporizador não pode ser coletado pelo coletor de lixo até disparar. Em um laço apertado, use time.NewTimer + Reset para evitar um vazamento de temporizador.

Prazo final versus tempo limite

Um tempo limite é uma duração relativa ("aguarde 5 s"). Um prazo final é um horário absoluto ("aguarde até 14h00"). Use time.Until(deadline) para converter um prazo final em uma duração para time.After.

deadline := time.Now().Add(5 * time.Second)
select {
case v := <-ch:
    use(v)
case <-time.After(time.Until(deadline)):
    fmt.Println("deadline exceeded")
}

context.WithTimeout é a opção preferida

Para manipuladores HTTP e tarefas estruturadas, prefira context.WithTimeout a tempos limite brutos baseados em canais — ele propaga o cancelamento automaticamente pela pilha de chamadas.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Limitação de taxa com Ticker

Um temporizador periódico é o limitador de taxa mais simples: envie uma solicitação a cada sinal. Para permitir rajadas, preencha previamente um canal com buffer e reabasteça-o com um temporizador periódico.

requests := make(chan int, 5)
for i := 0; i < 5; i++ { requests <- i }
close(requests)
limiter := time.NewTicker(200 * time.Millisecond)
for req := range requests {
    <-limiter.C
    fmt.Println("request", req)
}

Relógio monotônico

As durações dos temporizadores do Go usam o relógio monotônico, não o relógio de parede, portanto não são afetadas por ajustes no relógio do sistema. time.Since e time.Until também o utilizam.

Como interromper corretamente um temporizador periódico

Após ticker.Stop(), o canal do temporizador periódico NÃO é fechado — ele apenas deixa de receber valores. Se necessário, drene qualquer valor pendente do canal antes de retornar.

Verificação rápida

Por que time.NewTicker é preferível a time.Tick?

Recapitulação: tempos limite e temporizadores periódicos

Pontos principais:

time.After para um tempo limite de uso único em uma seleção
time.NewTicker para tarefas repetidas; sempre chame Stop()
evite time.After em laços — ele vaza temporizadores
prefira context.WithTimeout para tarefas que possam ser canceladas

Perguntas Frequentes

A aula “Timeouts e temporizadores” é grátis?

Sim — o texto completo de “Timeouts e temporizadores” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Timeouts e temporizadores”?

Use time.After e time.Tick com select Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Timeouts e temporizadores”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy