Go Academy · Aula

Temporizadores e marcadores

Agende e repita tarefas

Temporizadores e marcadores é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 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.

Pausando com Sleep

A ferramenta de agendamento mais simples é time.Sleep(d), que pausa a gorrotina atual por uma duração.

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(10 * time.Millisecond)
    fmt.Println("done")
}

O que é um temporizador?

Um time.Timer é acionado uma vez após um atraso. Quando expira, ele envia o horário atual pelo canal C.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(10 * time.Millisecond)
    <-t.C
    fmt.Println("timer fired")
}

Atalho time.After

time.After(d) retorna um canal que fornece um valor após o atraso. É um temporizador conveniente de uso único, sem uma variável.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(10 * time.Millisecond)
    fmt.Println("elapsed")
}

Parando um temporizador

timer.Stop() cancela um temporizador antes que ele seja acionado. Ele retorna true se conseguir pará-lo a tempo.

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(time.Hour)
    stopped := t.Stop()
    fmt.Println("stopped:", stopped)
}

O que é um marcador de intervalos?

Um time.Ticker é acionado repetidamente em um intervalo fixo, enviando dados pelo canal C a cada vez.

Use-o para tarefas periódicas, como consultar dados ou gerar quadros de animação.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    <-ticker.C
    fmt.Println("tick")
    ticker.Stop()
}

Contando os acionamentos

Percorra o canal do marcador de intervalos para agir a cada intervalo e pare depois de um número suficiente de acionamentos.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    for i := 1; i <= 3; i++ {
        <-ticker.C
        fmt.Println("tick", i)
    }
    ticker.Stop()
}

Sempre pare um marcador de intervalos

Ao contrário dos temporizadores, um marcador de intervalos continua funcionando até que você chame Stop(). Esquecer de pará-lo causa vazamento de recursos.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    <-ticker.C
    fmt.Println("one tick, will stop on return")
}

Conveniência de time.Tick

time.Tick(d) retorna diretamente um canal de acionamentos. É simples, mas não pode ser parado; portanto, use-o somente durante toda a vida útil do programa.

package main

import (
    "fmt"
    "time"
)

func main() {
    c := time.Tick(5 * time.Millisecond)
    <-c
    fmt.Println("ticked")
}

Tempo limite com select

Combine um canal de trabalho com time.After em um select para implementar um tempo limite.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go func() { done <- true }()
    select {
    case <-done:
        fmt.Println("work finished")
    case <-time.After(time.Second):
        fmt.Println("timed out")
    }
}

AfterFunc executa uma função de retorno

time.AfterFunc(d, f) executa a função f em sua própria gorrotina após o atraso, sem que você precise ler um canal.

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    time.AfterFunc(10*time.Millisecond, func() {
        fmt.Println("callback ran")
        done <- true
    })
    <-done
}

Temporizador ou marcador de intervalos

Escolha com base na repetição:

Temporizador: é acionado uma vez após um atraso.
Marcador de intervalos: é acionado repetidamente em um intervalo.
Pare ambos quando terminar para liberar recursos.

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(5 * time.Millisecond)
    fmt.Println("one-shot complete")
}

Verificação rápida

Qual tipo é acionado repetidamente em um intervalo fixo?

Recapitulação: temporizadores e marcadores de intervalos

Você aprendeu a agendar tarefas:

Sleep pausa; Timer e time.After são acionados uma vez.
Ticker e time.Tick são acionados repetidamente.
Use Stop() para liberar recursos; combine-o com select para implementar tempos limite.

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    for i := 0; i < 2; i++ {
        <-ticker.C
        fmt.Println("beat")
    }
}

Perguntas Frequentes

A aula “Temporizadores e marcadores” é grátis?

Sim — o texto completo de “Temporizadores e marcadores” é 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 “Temporizadores e marcadores”?

Agende e repita tarefas 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 3 de 4.

Quanto tempo leva a aula “Temporizadores e marcadores”?

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