Aula 35 - Tutorial Golang - Tickers

Aula 35 - Tutorial Golang - Tickers

• Um Timer representa um único evento no futuro.
• Ele é criado com time.NewTimer(duração), onde a "duração" é o período de tempo que o temporizador aguardará antes de disparar.
• Quando o Timer expira, ele envia um valor para o canal C associado a ele.
• O Timer pode ser usado para executar uma tarefa única após um determinado intervalo de tempo.
• Ele pode ser cancelado antes de expirar usando o método Stop().
• É útil quando você deseja agendar uma única execução no futuro e pode cancelar essa execução se necessário.

• Um Ticker é semelhante a um Timer, mas dispara repetidamente em intervalos regulares.
• Ele é criado com time.NewTicker(intervalo), onde o "intervalo" é o período de tempo entre cada disparo.
• O Ticker envia regularmente valores para o canal C associado a ele, a cada intervalo definido.
• Os Tickers são ideais para tarefas que precisam ser repetidamente executadas em intervalos fixos.
• Os Tickers não podem ser cancelados, portanto, eles continuam disparando até que o programa seja interrompido.

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)
	}
}

1. Ticker: O Ticker é uma abstração que encapsula essa lógica de forma mais direta e explícita. Ele foi projetado especificamente para repetir tarefas em intervalos regulares, e é a opção preferida quando você tem essa necessidade.
2. Timer: O Timer, como está sendo usado no código acima, pode ser uma alternativa quando você precisa de um comportamento mais flexível, como agendar uma tarefa única no futuro com a capacidade de cancelá-la. Nesse exemplo acima, o código está basicamente transformando um Timer em algo que se comporta como um Ticker.

Exemplo 01

package main

import (
    "fmt"
    "time"
)

func main() {

    // Tickers use a similar mechanism to timers: a
    // channel that is sent values. Here we'll use the
    // `select` builtin on the channel to await the
    // values as they arrive every 1000ms.
    ticker := time.NewTicker(1000 * time.Millisecond)
    done := make(chan bool)

    go func() {
        for {
            select {
                case <- done:
                    return
                case t := <- ticker.C:
                    fmt.Println("Tick at", t)
            }
        }
    }()

    // Tickers can be stopped like timers. Once a ticker
    // is stopped it won't receive any more values on its
    // channel. We'll stop ours after 5000ms.
    time.Sleep(5000 * time.Millisecond)
    ticker.Stop()
    done <- true
    fmt.Println("Ticker stopped")
}

Explicação do exemplo 01

package main

import (
	"fmt"
	"time"
)

func enviarEmail() {
	fmt.Println("Enviando e-mail...")
}

func main() {
	ticker := time.NewTicker(1 * time.Hour)

	for range ticker.C {
		enviarEmail()
	}
}

package main

import (
	"fmt"
	"time"
)

func exibirRelogio() {
	fmt.Println("Horário atual:", time.Now().Format("15:04:05"))
}

func main() {
	ticker := time.NewTicker(1 * time.Second)

	for range ticker.C {
		exibirRelogio()
	}
}

package main

import (
	"fmt"
	"time"
)

func atualizarDadosOnline() {
	fmt.Println("Atualizando dados online...")
}

func main() {
	ticker := time.NewTicker(30 * time.Second)

	go func() {
		for range ticker.C {
			atualizarDadosOnline()
		}
	}()

	// Simula o tempo para observar as atualizações
	time.Sleep(5 * time.Minute)
	ticker.Stop()
	fmt.Println("Atualizações online interrompidas")
}

package main

import (
	"fmt"
	"time"
)

func lerSensor() {
	fmt.Println("Lendo sensor...")
}

func main() {
	ticker := time.NewTicker(10 * time.Minute)

	go func() {
		for range ticker.C {
			lerSensor()
		}
	}()

	// Simula o tempo para observar a leitura dos sensores
	time.Sleep(1 * time.Hour)
	ticker.Stop()
	fmt.Println("Leitura de sensores interrompida")
}