Do czego służy pakiet `context`?

Question

Accepted Answer

Pakiet **`context`** przenosi **sygnały anulowania, terminy i wartości właściwe dla żądania** przez granice API i goroutine'ów. Jest standardowym mechanizmem do kontrolowania czasu trwania operacji — szczególnie do anulowania pracy i propagacji limitów czasu przez łańcuch wywołań funkcji.

## Podstawowy problem, który rozwiązuje

```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.
```

## Tworzenie kontekstów

```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` wywodzą kontekst podrzędny, który można anulować; musisz wywołać `defer cancel()`, aby uwolnić jego zasoby.

## Reagowanie na anulowanie

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

Funkcje sprawdzają `ctx.Done()` (kanał, który zamyka się po anulowaniu) i zatrzymują się szybko — w ten sposób anulowanie faktycznie się propaguje.

## Przesyłanie kontekstu przez łańcuch wywołań (konwencja)

```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
}
```

Kontekst płynie w dół stosu wywołań jako pierwszy parametr, więc anulowanie dociera do każdej warstwy (w tym do wywołań biblioteki standardowej DB/HTTP akceptujących kontekst).

## Wartości właściwe dla żądania (używaj oszczędnie)

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

## Dlaczego to ważne

Pakiet `context` jest fundamentalny dla pisania niezawodnych, gotowych do produkcji usług Go — jest to standardowy, idiomatyczny sposób obsługi **anulowania i limitów czasu** w goroutine'ach i przez granice API.

Jego pierwotna wartość to zapobieganie marnotrawstwu pracy i wyciekom zasobów: gdy klient się rozłączy, przekroczony zostanie termin lub serwer się wyłączy, kontekst propaguje sygnał anulowania, tak aby wszystkie goroutine'ów i operacje uruchomione dla tego żądania zatrzymały się szybko zamiast działać bezużytecznie (kluczowa obrona przed wyciekami goroutine'ów).

Jest wszechobecny w rzeczywistym Go — serwery HTTP, wywołania baz danych, gRPC i większość bibliotek sieciowych akceptuje `context.Context` jako pierwszy parametr.

Zrozumienie tworzenia kontekstów (`WithTimeout`/`WithCancel`), reagowania na anulowanie (`<-ctx.Done()`), reguły konieczności wywołania `cancel()` i konwencji przekazywania kontekstu przez łańcuchy wywołań jest niezbędne dla każdej poważnej pracy nad backendem Go i jest częstym tematem rozmów kwalifikacyjnych.