Kam naudojamas `context` paketas?

Question

Accepted Answer

**`context`** paketas perneša **atšaukimo signalus, terminus ir su užklausa susijusias reikšmes** per API ribas ir goroutines. Tai standartinis mechanizmas operacijų gyvavimo laikotarpiui valdyti — ypač darbui atšaukti ir timeout'ams platinti per funkcijų iškvietimų grandinę.

## Pagrindinė problema, kurią jis sprendžia

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

## Context kūrimas

```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` išveda vaiko kontekstą, kuris gali būti atšauktas; turite `defer cancel()` jei norite atlaisvinti jo išteklius.

## Atsakymas į atšaukimą

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

Funkcijos tikrina `ctx.Done()` (kanalą, kuris užsidaro atšaukus) ir iškart sustoja — taip atšaukimas faktiškai sklinda.

## Context perduodimas per iškvietimų grandinę (konvencija)

```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 teka žemyn į iškvietimų steko viršų kaip pirmasis parametras, todėl atšaukimas pasiekia kiekvieną sluoksnį (įskaitant standartinės bibliotekos DB/HTTP iškvietimus, kurie priima kontekstą).

## Su užklausa susiję pasiūlymai (naudokite atsargiai)

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

## Kodėl tai svarbu

`context` paketas yra svarbu parašyti patikimus, gamybinio lygio Go servisus — tai standartinis, idiominis būdas valdyti **atšaukimą ir timeout'us** per goroutines ir API ribas.

Jo pagrindinė vertė yra naudingos darbo ir išteklių nuotėkio prevencija: kai klientas atsisakoja jungties, baigsi terminas arba serveris išsijungia, kontekstas platina atšaukimo signalą, kad visi goroutines ir operacijos, pradėtos tam užklausai, iškart sustotų, o ne bėgtų bergždžiai (pagrindinė apsauga nuo goroutine nuotėkio).

Jis yra visur realiame Go — HTTP serveriuose, duomenų bazės iškvietimuose, gRPC ir daugumoje tinklo bibliotekų yra priimamas `context.Context` kaip pirmasis parametras.

Suprasti, kaip kurti context (`WithTimeout`/`WithCancel`), kaip atsakyti į atšaukimą (`<-ctx.Done()`), `cancel()` privalo būti iškviečiama taisyklė ir konvenciją laiduoti kontekstą per iškvietimų grandinę, yra būtina bet kokiam rimtam Go backend darbui ir dažna pokalbio tema.