Mihin context-pakettia käytetään?

Question

Accepted Answer

**`context`**-paketti kuljettaa **peruutussignaaleja, määräaikoja ja pyynnön rajattuja arvoja** API-rajojen ja goroutinejen yli. Se on vakiomekanismi operaatioiden elinkaaren hallintaan — erityisesti työn peruuttamiseen ja aikakatkojen levittämiseen funktiokutsusarjojen läpi.

## Ydinongelman, jonka se ratkaisee

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

## Kontekstien luominen

```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` johtaa alaikäisen kontekstin, joka voidaan peruuttaa; sinun on käytettävä `defer cancel()` sen resurssien vapauttamiseen.

## Peruutukseen vastaaminen

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

Funktiot tarkistavat `ctx.Done()` (kanavan, joka sulkeutuu peruutuksessa) ja pysähtyvät pian — näin peruutus todellakin leviää.

## Kontekstin välittäminen kutsusarjan läpi (sopimus)

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

Konteksti virtaa alas kutsupinoa ensimmäisenä parametrina, joten peruutus saavuttaa jokaisen kerroksen (myös vakiokirjastoon kuuluvat DB/HTTP-kutsuihin, jotka hyväksyvät kontekstin).

## Pyynnön rajattavat arvot (käytä säästäväisesti)

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

## Miksi tämä on tärkeää

`context`-paketti on olennainen vankkaan, tuotantoasteisiin Go-palveluihin kirjoittamiseen — se on vakio, idiomatinen tapa hallita **peruutuksia ja aikakatoja** goroutinejen ja API-rajojen yli.

Sen ensisijainen arvo on turhien töiden ja resurssivuotojen estäminen: kun asiakas irtoaa, määräaika umpeutuu tai palvelin sulkeutuu, konteksti levittää peruutussignaalin niin, että kaikki kyseiselle pyynnölle luodut goroutinet ja operaatiot pysähtyvät välittömästi turhaan juoksemisen sijaan (goroutine-vuotojen keskeinen puolustus).

Se on laajalle levinnyt todellisissa Go-ohjelmissa — HTTP-palvelimet, tietokantakutsuutit, gRPC ja useimmat verkkokirjastot hyväksyvät `context.Context` ensimmäisenä parametrinaan.

Ymmärtäminen kontekstien luomisesta (`WithTimeout`/`WithCancel`), peruutukseen vastaaminen (`<-ctx.Done()`), must-call-`cancel()`-sääntö ja kontekstin välittämisen sopimus kutsusarjojen läpi on välttämätöntä mille tahansa vakavalle Go-tausta-työlle ja yleinen haastattelun aihe.