Welke volgorde van acties is nodig om de applicatie correct te stoppen zonder gegevens te verliezen of fouten te veroorzaken?

Om een Go-toepassing correct te stoppen zonder gegevensverlies en fouten, worden meestal de volgende stappen gevolgd:

1. Systeemsignalen afhandelen — signalen zoals (SIGINT, SIGTERM) opvangen met behulp van een kanaal en signal.Notify.

2. Graceful shutdown starten — een procedure voor een soepele afsluiting starten, die nieuwe verzoeken stopt en lopende verzoeken laat afronden.

3. Context annuleren — gebruik maken van context.Context met annulering om het stop-signaal door te geven aan alle goroutines.

4. Resources sluiten — open verbindingen met databases, bestanden, netwerkverbindingen sluiten.

5. Wachten tot alle goroutines klaar zijn — met behulp van sync.WaitGroup of andere mechanismen wachten tot alle operaties voltooid zijn.

Voorbeeld van signaalafhandeling en graceful shutdown:

import (
    "context"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup

    // Applicatie starten
    wg.Add(1)
    go func() {
        defer wg.Done()
        runApp(ctx) // hoofdlogica functie
    }()

    // Signaalafhandeling
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    <-sigs // wacht op signaal
    cancel() // annuleer de context, signaleer goroutines

    // Wacht tot alles klaar is
    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    select {
    case <-done:
        // alles klaar
    case <-time.After(10 * time.Second):
        // timeout
    }
}

Deze aanpak helpt dataverlies en incorrecte afsluiting te voorkomen.