Go Academy · Lektion

Geordnetes Herunterfahren

Worker sauber stoppen

Geordnetes Herunterfahren ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum ein Graceful Shutdown

Lang laufende Goroutinen müssen erfahren, wann sie beendet werden sollen. Graceful Shutdown ermöglicht es Workern, ihre aktuelle Arbeit abzuschließen, Ressourcen freizugeben und sich zu beenden, ohne Leaks zu verursachen oder Daten zu verlieren.

Keine Goroutine-Leaks
Keine unvollständigen Schreibvorgänge
Sauberes Beenden des Prozesses

Das done-Kanal-Muster

Ein klassischer Ansatz ist ein done-Kanal. Wenn Sie ihn schließen, sendet er ein Stoppsignal an alle Goroutinen, die auf ihn warten, denn ein geschlossener Kanal liefert beim Lesen sofort zurück.

done := make(chan struct{})
// ... later
close(done)

select für Stoppsignale

Eine Worker-Goroutine verwendet select, um entweder einen Job zu verarbeiten oder den done-Kanal zu erkennen. Wenn done geschlossen wird, wird dieser Case ausgeführt und die Worker-Goroutine kehrt zurück.

for {
    select {
    case <-done:
        return
    case j := <-jobs:
        process(j)
    }
}

context.Context

Das idiomatische moderne Werkzeug ist context. context.WithCancel liefert einen Kontext und eine Abbruchfunktion. Der Aufruf von cancel schließt den Done-Kanal des Kontexts.

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

Auf ctx.Done() warten

Worker verwenden ctx.Done() in einer Select-Anweisung. Wenn cancel aufgerufen wird oder eine Deadline abläuft, wird der Kanal geschlossen und der Worker beendet sich.

select {
case <-ctx.Done():
    return ctx.Err()
case j := <-jobs:
    process(j)
}

Auf Worker warten

Ein Stoppsignal allein reicht nicht aus; Sie müssen warten, bis die Worker tatsächlich beendet sind. Eine sync.WaitGroup verfolgt sie, sodass main blockieren kann, bis der Zähler null erreicht.

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()

Timeouts mit context

context.WithTimeout bricht nach einer bestimmten Dauer automatisch ab. Dadurch wird begrenzt, wie lange das Herunterfahren dauern darf, bevor Sie das Programm zwangsweise beenden.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Ein vollständiger Graceful Shutdown

Dieses Programm führt zwei Worker aus, bricht den Kontext ab und wartet, bis beide sauber beendet sind, bevor es done ausgibt.

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d stopping\n", id)
            return
        case <-time.After(50 * time.Millisecond):
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    for i := 1; i <= 2; i++ {
        wg.Add(1)
        go worker(ctx, i, &wg)
    }
    time.Sleep(120 * time.Millisecond)
    cancel()
    wg.Wait()
    fmt.Println("all workers stopped")
}

Laufende Arbeit abarbeiten

Beim Herunterfahren sollen Worker häufig die bereits begonnene Arbeit abschließen. Lesen Sie verbleibende Jobs in einer abschließenden Schleife ein oder nehmen Sie keine neuen Jobs mehr an, während die aktuellen abgeschlossen werden.

Betriebssignale abfangen

In echten Servern verknüpft signal.NotifyContext den Abbruch mit SIGINT und SIGTERM. Wenn Sie Ctrl+C drücken, wird derselbe Graceful-Shutdown-Ablauf wie bei einem manuellen Abbruch ausgelöst.

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

Never Forget cancel()

Rufen Sie immer defer cancel() auf, auch bei Verwendung von WithTimeout. Wenn cancel nicht aufgerufen wird, bleiben die interne Goroutine und der Timer des Kontexts bis zum Ablauf der Deadline bestehen.

Kurztest

Testen Sie Ihr Wissen über das Herunterfahren.

Zusammenfassung

Sie haben den Graceful Shutdown gelernt:

Verwenden Sie context.WithCancel oder einen done-Kanal, um das Beenden zu signalisieren
Worker warten auf ctx.Done()
Die WaitGroup stellt sicher, dass alle Worker tatsächlich beendet werden
Verknüpfen Sie den Abbruch bei echten Servern mit Betriebssignalen
Verwenden Sie immer defer cancel()

Häufig gestellte Fragen

Ist die Lektion „Geordnetes Herunterfahren“ kostenlos?

Ja — der vollständige Text von „Geordnetes Herunterfahren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Geordnetes Herunterfahren“?

Worker sauber stoppen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Geordnetes Herunterfahren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy