Mire szolgál a context csomag?

Question

Accepted Answer

A **`context`** csomag **törlési jelzéseket, határidőket és kéréshez kötött értékeket** szállít az API-határok és goroutinek között. Ez az operációk élettartamának szabályozására szolgáló standard mechanizmus — különösen a munka törlésére és az időtúllépések propagálására a függvényhívások lánca keresztül.

## Az alapvető probléma, amit megold

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

## Kontextusok létrehozása

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

A `WithTimeout`/`WithDeadline`/`WithCancel` egy gyermek kontextust hoz létre, amely törölhető; meg kell hívnod a `defer cancel()` kifejezést az erőforrások felszabadítására.

## Válasz a törlésre

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

A függvények ellenőrzik a `ctx.Done()` értékét (egy olyan csatorna, amely a törléskor lezárul) és azonnal megállnak — így működik a törlés propagálása.

## Kontextus átadása a hívási lánc mentén (a konvenció)

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

A kontextus lefelé halad a hívási verem mentén, mint az első paraméter, így a törlés minden réteghez eljut (beleértve a kontextust elfogadó szabvány könyvtári DB/HTTP hívásokat is).

## Kéréshez kötött értékek (használd takarékosan)

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

## Miért fontos

A `context` csomag alapvetően fontosabb a robusztus, termelési szintű Go szolgáltatások írásához — ez a standard, idiomatikus módja a **törléseknek és időtúllépéseknek** a goroutinek és API-határok között.

Az alapvető értéke a hulladék munka és az erőforrásszivárgás megelőzése: amikor egy kliens lecsatlakozik, egy határidő lejár, vagy egy szerver leállásnak indul, a kontextus propagálja a törlési jelet, így az adott kéréshez indított összes goroutin és operáció azonnal megáll, ahelyett, hogy haszontalanul futna (ez a goroutin-szivárgás elleni kulcsvédelem).

Ez mindenhol jelen van az igazi Go-ban — a HTTP szerverek, az adatbázis-hívások, a gRPC és a legtöbb hálózati könyvtár elfogadja a `context.Context` értéket első paraméterként.

Annak megértése, hogyan kell kontextusokat létrehozni (`WithTimeout`/`WithCancel`), válaszolni a törlésre (`<-ctx.Done()`), a `cancel()` meghívásának kötelezősége és a kontextus hívási láncon keresztüli átadásának konvenciója elengedhetetlen a komolyabb Go backend munka számára, és egy gyakori interjúkérdés.