Go Academy · Lezione

Arresto graduale dei job

Arrestare correttamente i job

Arresto graduale dei job è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Arrestare correttamente i job

Uno scheduler terminato durante un job può danneggiare i dati o lasciare un'operazione a metà. Per arresto controllato si intende: smettere di accettare nuove esecuzioni, lasciare terminare i job in corso (entro una scadenza), quindi uscire.

Ascoltare i segnali

Intercetti segnali del sistema operativo come SIGINT (Ctrl+C) e SIGTERM (arresto da parte dell'orchestratore), così può eseguire un arresto intenzionale.

sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
<-sig
fmt.Println("shutting down")

signal.NotifyContext

Go 1.16+ offre un pratico helper che annulla un contesto quando arriva un segnale.

ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
<-ctx.Done()

Arrestare lo scheduler

Con robfig/cron, c.Stop() restituisce un contesto che risulta completato quando tutti i job in esecuzione terminano. Attenda il suo completamento per consentire lo smaltimento dei job.

ctx := c.Stop()        // stops scheduling, returns ctx
<-ctx.Done()            // wait for running jobs
fmt.Println("all jobs finished")

Propagare l'annullamento ai job

Passi un contesto a ogni job, così le operazioni di lunga durata possono interrompersi rapidamente quando inizia l'arresto.

func job(ctx context.Context) {
    select {
    case <-time.After(time.Hour):
    case <-ctx.Done():
        return // bail out early
    }
}

Limitare l'attesa

Non attenda all'infinito i job bloccati. Usi un contesto con timeout, così l'arresto viene completato anche se un job rimane in sospeso.

shutCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

WaitGroup per scheduler personalizzati

Se crea uno scheduler personalizzato con le goroutine, ne tenga traccia con un sync.WaitGroup ed esegua Wait() durante l'arresto.

var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); doWork() }()
// shutdown:
wg.Wait()

Evitare di avviare nuovo lavoro

Quando inizia l'arresto, il ticker o cron deve smettere di attivarsi. Chiudere un canale done o annullare il contesto garantisce che il ciclo rilevi il segnale e smetta di pianificare nuove esecuzioni.

L'idempotenza è utile

Progetti i job in modo che sia sicuro eseguirli di nuovo. Se un job viene terminato a metà e ritentato dopo il riavvio, una logica idempotente evita effetti duplicati, come l'invio di doppie email o l'addebito doppio.

Schema completo

Unendo tutti gli elementi: un contesto che riceve notifiche dei segnali, un Stop di cron che restituisce un contesto per lo smaltimento dei job e un timeout limitato. Questo è lo schema standard per l'arresto controllato dei servizi pianificati.

Eseguibile: arresto controllato con il contesto

Questo programma autonomo esegue un worker periodico e lo arresta correttamente annullando il contesto, dopo aver atteso il completamento del tick in corso.

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        t := time.NewTicker(5 * time.Millisecond)
        defer t.Stop()
        for {
            select {
            case <-t.C:
                fmt.Println("working")
            case <-ctx.Done():
                fmt.Println("stopping cleanly")
                return
            }
        }
    }()
    time.Sleep(17 * time.Millisecond)
    cancel()   // signal shutdown
    wg.Wait()  // wait for worker to finish
    fmt.Println("shutdown complete")
}

Verifica rapida

Verifichi la Sua comprensione dell'arresto controllato dei job.

Riepilogo

Ha imparato a gestire l'arresto controllato dei job:

Intercetti SIGINT/SIGTERM, idealmente tramite signal.NotifyContext
cron.Stop() restituisce un contesto che attende il completamento dei job in esecuzione
Propaghi il contesto ai job e limiti l'attesa con un timeout
Renda i job idempotenti, così i tentativi successivi sono sicuri

Domande Frequenti

La lezione «Arresto graduale dei job» è gratuita?

Sì — il testo completo di «Arresto graduale dei job» è 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 «Arresto graduale dei job»?

Arrestare correttamente i job 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 4 di 4.

Quanto tempo richiede la lezione «Arresto graduale dei job»?

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