Wofür wird das context-Paket verwendet?

Question

Accepted Answer

Das **`context`**-Paket transportiert **Abbruchsignale, Deadlines und Request-scoped Werte** über API-Grenzen und Goroutines. Es ist der Standardmechanismus zur Steuerung der Lebensdauer von Operationen — besonders zum Abbrechen von Aufgaben und zum Propagieren von Timeouts durch eine Kette von Funktionsaufrufen.

## Das Kernproblem, das es löst

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Erstellen von Kontexten

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` leiten einen untergeordneten Kontext ab, der abgebrochen werden kann; du musst `defer cancel()` aufrufen, um seine Ressourcen freizugeben.

## Reaktion auf Abbruch

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Funktionen prüfen `ctx.Done()` (ein Kanal, der bei Abbruch geschlossen wird) und stoppen umgehend — so wird der Abbruch tatsächlich propagiert.

## Context über eine Aufrufkette weitergeben (die Konvention)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Context fließt den Aufrufen als erster Parameter hinab, damit der Abbruch jede Schicht erreicht (einschließlich Standard-Library DB/HTTP-Aufrufen, die einen Context akzeptieren).

## Request-scoped Werte (sparsam verwenden)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## Warum es wichtig ist

Das `context`-Paket ist grundlegend für das Schreiben robuster Go-Services auf Produktionsniveau — es ist die Standard-, idiomatische Methode zum Umgang mit **Abbruch und Timeouts** über Goroutines und API-Grenzen.

Sein Hauptwert liegt in der Vermeidung verschwendeter Arbeit und Ressourcenlecks: Wenn ein Client sich trennt, ein Deadline verstreicht oder ein Server herunterfährt, propagiert Context das Abbruchsignal, sodass alle für diese Anfrage generierten Goroutines und Operationen sofort anhalten, anstatt sinnlos weiterzulaufen (eine wichtige Abwehr gegen Goroutine-Lecks).

Es ist in echtem Go allgegenwärtig — HTTP-Server, Datenbankaufrufe, gRPC und die meisten Netzwerkbibliotheken akzeptieren `context.Context` als ihren ersten Parameter.

Das Verständnis, wie man Kontexte erstellt (`WithTimeout`/`WithCancel`), auf Abbruch reagiert (`<-ctx.Done()`), die Regel must-call-`cancel()` und die Konvention, Context durch Aufrufketten zu leiten, sind wesentlich für ernsthafte Go-Backend-Arbeiten und ein häufiges Interviewthema.