Go Academy · Lezione

Pianificazione basata sul tempo

Eseguire attività periodiche

Lezione 1 di 413 passaggi

Pianificazione basata sul tempo è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Eseguire attività secondo una pianificazione

Molti sistemi devono eseguire attività periodiche: eliminare i file temporanei ogni notte, inviare un'email riepilogativa ogni mattina o interrogare un'API ogni minuto. Questa lezione introduce la pianificazione basata sul tempo in Go utilizzando la libreria standard.

Il pacchetto time

Il pacchetto time di Go è il fondamento. Strumenti principali:

time.Sleep mette in pausa una goroutine
time.After restituisce un canale che si attiva una volta
time.Ticker si attiva ripetutamente
time.Timer si attiva una volta dopo un ritardo

Un ciclo ingenuo

Lo scheduler più semplice: eseguire l'attività, attendere, ripetere.

package main

import (
    "fmt"
    "time"
)

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

Perché Sleep causa deriva

Un ciclo con sleep accumula deriva: se l'attività richiede 200ms e si attende 1s, l'intervallo effettivo è di 1.2s e la differenza si accumula. Per ottenere intervalli accurati, utilizzi un Ticker, argomento trattato in una lezione successiva.

time.After per ritardi una tantum

time.After(d) restituisce un canale su cui viene ricevuto un valore una volta trascorsa la durata d. È utile in un select per implementare i timeout.

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

time.Timer

Un Timer si attiva una volta e può essere arrestato o reimpostato, a differenza di time.After, che non è possibile annullare.

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

Pianificare a un'ora specifica

Per eseguire un'attività, ad esempio, alle 3 del mattino, calcoli la durata fino a quel momento e attenda o imposti un timer per tale durata, quindi pianifichi nuovamente l'attività per il giorno successivo.

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

Le durate sono tipizzate

time.Duration è un int64 espresso in nanosecondi e dispone di costanti pratiche: time.Second, time.Minute, time.Hour. Le moltiplichi per ottenere intervalli leggibili.

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

Orologio monotono e orologio civile

time.Now di Go include una lettura monotona utilizzata per misurare il tempo trascorso, immune alle correzioni dell'orologio. Utilizzi time.Since per le durate, invece di sottrarre valori dell'orologio civile.

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

Quando ricorrere a una libreria

Per pianificazioni complesse ("ogni giorno feriale alle 9:15"), calcolare manualmente i tempi è soggetto a errori. La libreria robfig/cron, trattata nella prossima lezione, analizza le espressioni cron al posto Suo.

Eseguibile: calcolare la prossima esecuzione

Questo programma autonomo calcola quanto tempo manca al prossimo cambio di minuto utilizzando solo il pacchetto 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 rapida

Verifichi la propria comprensione della pianificazione basata sul tempo.

Rispondi nella lezione interattiva

Riepilogo

Ha appreso le basi della pianificazione basata sul tempo:

Il pacchetto time fornisce Sleep, After, Timer e Ticker
I cicli con Sleep accumulano deriva; i ticker rispettano la pianificazione
Calcoli le durate fino a un orario di destinazione con time.Until
Utilizzi time.Since e l'orologio monotono per misurare il tempo trascorso

Gratis per iniziare

Impara Go con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 51
Lezioni: 203

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Pianificazione basata sul tempo» è gratuita?

Sì — il testo completo di «Pianificazione basata sul tempo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Pianificazione basata sul tempo»?

Eseguire attività periodiche Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Pianificazione basata sul tempo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy