Go Academy · Aula

Agendamento baseado em tempo

Execute tarefas periódicas

Agendamento baseado em tempo é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

Executando tarefas em uma programação

Muitos sistemas precisam de tarefas periódicas: limpar arquivos temporários todas as noites, enviar um e-mail de resumo todas as manhãs ou consultar uma API a cada minuto. Esta lição apresenta o agendamento baseado em tempo no Go usando a biblioteca padrão.

O pacote time

O pacote time do Go é a base. Principais ferramentas:

time.Sleep pausa uma gorrotina
time.After retorna um canal que dispara uma vez
time.Ticker dispara repetidamente
time.Timer dispara uma vez após um atraso

Um loop ingênuo

O agendador mais simples: faça o trabalho, aguarde e repita.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        fmt.Println("tick", i)
        time.Sleep(10 * time.Millisecond)
    }
}

Por que Sleep sofre deriva

Um loop com espera sofre deriva: se o trabalho levar 200 ms e você aguardar 1 s, seu intervalo real será de 1,2 s, e essa diferença se acumulará. Para obter intervalos precisos, use um Ticker, abordado em uma lição posterior.

time.After para atrasos únicos

time.After(d) retorna um canal que recebe um valor uma vez após a duração d. É útil em select para prazos.

select {
case <-time.After(2 * time.Second):
    fmt.Println("2s elapsed")
}

time.Timer

Um Timer dispara uma vez e pode ser parado ou redefinido, ao contrário de time.After, que não pode ser cancelado.

t := time.NewTimer(5 * time.Second)
defer t.Stop()
<-t.C
fmt.Println("fired")

Agendando para um horário específico

Para executar algo, por exemplo, às 3 AM, calcule a duração até esse momento e aguarde ou use um temporizador durante esse período; depois, reagende para o dia seguinte.

now := time.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), 3, 0, 0, 0, now.Location())
if next.Before(now) {
    next = next.Add(24 * time.Hour)
}
fmt.Println("sleep for", time.Until(next))

Durações têm tipo

time.Duration é um int64 de nanossegundos com constantes práticas: time.Second, time.Minute e time.Hour. Multiplique-as para obter intervalos legíveis.

every := 30 * time.Minute
fmt.Println(every)

Relógio monotônico versus relógio civil

O time.Now do Go inclui uma leitura monotônica usada para medir o tempo decorrido, imune a ajustes do relógio. Use time.Since para obter durações, não a subtração do relógio civil.

start := time.Now()
// ... work ...
fmt.Println("took", time.Since(start))

Quando recorrer a uma biblioteca

Para programações complexas ("toda segunda a sexta às 9:15"), fazer os cálculos de tempo manualmente é propenso a erros. A biblioteca robfig/cron, abordada a seguir, analisa expressões cron para você.

Executável: calculando a próxima execução

Este programa autocontido calcula quanto falta até o início do próximo minuto usando apenas o pacote time.

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Date(2026, 1, 1, 10, 30, 45, 0, time.UTC)
    nextMinute := now.Truncate(time.Minute).Add(time.Minute)
    fmt.Println("now:", now.Format("15:04:05"))
    fmt.Println("next run:", nextMinute.Format("15:04:05"))
    fmt.Println("wait:", nextMinute.Sub(now))
}

Verificação rápida

Teste sua compreensão do agendamento baseado em tempo.

Recapitulação

Você aprendeu os conceitos básicos do agendamento baseado em tempo:

O pacote time fornece Sleep, After, Timer e Ticker
Loops com Sleep sofrem deriva; tickers mantêm o agendamento
Calcule as durações até um horário-alvo com time.Until
Use time.Since e o relógio monotônico para medir o tempo decorrido

Perguntas Frequentes

A aula “Agendamento baseado em tempo” é grátis?

Sim — o texto completo de “Agendamento baseado em tempo” é 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 “Agendamento baseado em tempo”?

Execute tarefas periódicas 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 1 de 4.

Quanto tempo leva a aula “Agendamento baseado em tempo”?

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