A che cosa serve il package `context`?

Question

Accepted Answer

Il package **`context`** trasporta **segnali di cancellazione, scadenze e valori associati alle richieste** attraverso i confini delle API e i goroutine. È il meccanismo standard per controllare il ciclo di vita delle operazioni — in particolare per cancellare il lavoro e propagare i timeout attraverso una catena di chiamate di funzioni.

## Il problema principale che risolve

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

## Creazione di context

```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` derivano un context figlio che può essere cancellato; devi `defer cancel()` per liberare le sue risorse.

## Rispondere alla cancellazione

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

Le funzioni controllano `ctx.Done()` (un canale che si chiude alla cancellazione) e si fermano immediatamente — così la cancellazione si propaga effettivamente.

## Passare il context attraverso una catena di chiamate (la convenzione)

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

Il context scorre verso il basso nello stack di chiamate come primo parametro, in modo che la cancellazione raggiunga ogni livello (incluse le chiamate standard-library di DB/HTTP che accettano un context).

## Valori associati alle richieste (usare con parsimonia)

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

## Perché è importante

Il package `context` è fondamentale per scrivere servizi Go robusti e di livello production — è il modo standard e idiomatico per gestire **cancellazione e timeout** attraverso goroutine e confini delle API.

Il suo valore principale è prevenire sprechi di lavoro e perdite di risorse: quando un client si disconnette, una scadenza passa, o un server si spegne, il context propaga il segnale di cancellazione in modo che tutti i goroutine e le operazioni avviate per quella richiesta si fermino prontamente invece di eseguirsi inutilmente (una difesa chiave contro le perdite di goroutine).

È pervasivo nel Go reale — i server HTTP, le chiamate al database, gRPC e la maggior parte delle librerie di rete accettano un `context.Context` come primo parametro.

Comprendere come creare context (`WithTimeout`/`WithCancel`), come rispondere alla cancellazione (`<-ctx.Done()`), la regola di dover chiamare `cancel()`, e la convenzione di passare il context attraverso catene di chiamate è essenziale per qualsiasi lavoro serio di backend Go e un argomento comune nei colloqui.