Aula 34 – Tutorial Golang – Trabalhando com Temporizadores (Timers) em Go
Aula 34 – Tutorial Golang – Trabalhando com Temporizadores (Timers) em Go
Tutorial Golang
Compartilho com vocês conteúdo de qualidade de forma gratuita como parte da missão do Código Fluente.
No entanto, também quero apresentar uma oportunidade imperdível de aprimorar suas habilidades em programação para alcançar um nível avançado.
Conheça agora mesmo o curso Master Full Stack clicando no link abaixo 👇 e confira!
Pacote Programador Fullstack
Página principal do blog
Todas as aulas desse curso
Aula 33 Aula 35
Redes Sociais:
Meus links de afiliados:
Hostinger
Digital Ocean
One.com
Melhore seu NETWORKING
https://digitalinnovation.one/
Participe de comunidades de desenvolvedores:
Fiquem a vontade para me adicionar ao linkedin.
E também para me seguir no https://github.com/toticavalcanti.
Código final da aula:
https://github.com/toticavalcanti
Canais do Youtube
Toti
Lofi Music Zone Beats
Backing Track / Play-Along
Código Fluente
Putz!
Vocal Techniques and Exercises
PIX para doações
PIX Nubank
Aula 34 – Tutorial Golang – Trabalhando com Temporizadores (Timers) em Go
Nesta aula, vamos explorar os conceitos de temporizadores (timers) em Go.
Os temporizadores permitem executar código Go em algum momento futuro ou de forma repetida em intervalos definidos.
Vamos aprender como criar e usar temporizadores para agendar eventos e também como cancelar temporizadores antes que eles sejam executados.
Introdução aos Temporizadores (Timers)
Os temporizadores em Go são uma forma eficiente de agendar a execução de um código em um determinado momento futuro.
Eles são úteis quando você deseja executar tarefas em intervalos específicos, como criar uma tarefa programada que precisa ser executada em um horário predefinido ou realizar ações em intervalos regulares.
Criando um Temporizador (Timer)
Em Go, a biblioteca time fornece suporte para criar temporizadores. Para criar um temporizador, usamos a função time.NewTimer(duração), onde duração é o período de tempo que o temporizador aguardará antes de disparar.
Quando o temporizador expira, ele envia um valor para o canal C associado a ele.
package main
import (
"fmt"
"time"
)
func main() {
// Criando um temporizador que aguardará 2 segundos
timer := time.NewTimer(2 * time.Second)
// Bloqueando a execução até que o temporizador expire
<-timer.C
fmt.Println("Temporizador Expirou!")
}
Canal criado automaticamente
Tentando uma explicação mais didática da criação desse canal automaticamente, imagine que a função time.NewTimer(duração) é como uma fábrica que produz temporizadores. Quando você chama essa função, ela cria um temporizador especial para você. Esse temporizador inclui uma canal interno chamado C, que é usado para enviar notificações quando o tempo definido para o temporizador expirar.
Em termos mais simples, quando você cria um temporizador com time.NewTimer(), ele já vem com um canal embutido (C). Esse canal é uma espécie de “linha de comunicação” entre a função time.NewTimer() e a goroutine que o utiliza.
Utilizando time.Sleep vs. time.NewTimer
Embora seja possível esperar por um período de tempo usando time.Sleep, os time.NewTimer oferecem uma vantagem adicional.
Eles permitem que você cancele o temporizador antes que ele expire, o que pode ser útil em algumas situações.
Quando usamos time.Sleep, não temos a opção de cancelar o período de espera.
No entanto, com um temporizador, podemos cancelá-lo antes que ele seja acionado.
Cancelando um Temporizador
Para cancelar um temporizador, chamamos a função Stop() associada ao temporizador.
Se o temporizador não tiver expirado, Stop() retornará true, caso contrário, retornará false.
package main
import (
"fmt"
"time"
)
func main() {
// Criando um temporizador de 1 segundo
timer := time.NewTimer(time.Second)
// Executando uma goroutine para aguardar o temporizador expirar
go func() {
<-timer.C
fmt.Println("Temporizador Expirou!")
}()
// Aguardar um pouco para que o temporizador expire
// time.Sleep(2 * time.Second)
// Cancelando o temporizador antes que ele expire
if timer.Stop() {
fmt.Println("Temporizador Cancelado!")
} else {
fmt.Println("Temporizador Já Expirou e Não Pode Ser Cancelado!")
}
}
Explicação
O temporizador é criado com uma duração de 1 segundo (time.NewTimer(time.Second)).
Em seguida, uma goroutine é iniciada para esperar que o temporizador expire (<-timer.C).
Antes que o temporizador tenha a chance de expirar, chamamos timer.Stop() para tentar cancelá-lo.
O método Stop() retorna true se o temporizador ainda não tiver expirado e for cancelado com sucesso, e false caso contrário.
No código fornecido, como o tempo definido para o temporizador é de 1 segundo e, logo após a sua criação, imediatamente tentamos cancelá-lo, a condição timer.Stop() é avaliada como true.
Isso ocorre porque o temporizador não teve tempo suficiente para expirar.
Portanto, a mensagem “Temporizador Cancelado!” será impressa no console, indicando que o temporizador foi cancelado com sucesso antes de expirar.
Se você alterar o tempo do temporizador para algo maior do que o tempo que o programa leva para chegar à verificação timer.Stop(), a mensagem “Temporizador Já Expirou e Não Pode Ser Cancelado!” será impressa no console, pois o temporizador já terá expirado quando tentarmos cancelá-lo.
Casos de Uso
Agora, vamos ver alguns casos de uso em que os temporizadores são úteis.
Caso de Uso 1: Executar uma Tarefa Programada
Suponha que você queira executar uma tarefa em seu programa em um horário específico no futuro.
Você pode criar um temporizador para agendar a execução dessa tarefa no momento desejado.
package main
import (
"fmt"
"time"
)
func tarefaProgramada() {
fmt.Println("Tarefa Executada!")
}
func main() {
// Calculando o tempo para a próxima execução da tarefa (daqui a 5 segundos)
duracao := 5 * time.Second
temporizador := time.NewTimer(duracao)
// Bloqueando a execução até que o temporizador expire
<-temporizador.C
// Executando a tarefa programada
tarefaProgramada()
}
Caso de Uso 2: Notificação em Intervalos Regulares
Imagine que você deseja enviar uma notificação para o usuário a cada intervalo fixo de tempo.
Os temporizadores podem ser usados para agendar essas notificações em intervalos regulares.
package main
import (
"fmt"
"time"
)
func notificacao() {
fmt.Println("Notificação enviada!")
}
func main() {
// Criando um temporizador para notificação a cada 10 segundos
temporizador := time.NewTimer(5 * time.Second)
// Executando a notificação em um loop infinito
for {
<-temporizador.C
notificacao()
// Reiniciando o temporizador para o próximo intervalo
temporizador.Reset(5 * time.Second)
}
}
Nesta aula, aprendemos a trabalhar com temporizadores em Go, desde a criação e uso básico até casos de uso mais avançados.
Os temporizadores são uma ferramenta poderosa para agendar a execução de tarefas em momentos futuros ou em intervalos regulares, e a capacidade de cancelá-los antes da expiração pode ser útil em diversas situações.
Continue praticando e explorando os recursos dessa poderosa linguagem!
