Для чего используется пакет context?

Question

Accepted Answer

Пакет **`context`** передаёт **сигналы отмены, сроки выполнения и значения, привязанные к запросу** через границы API и горутины. Это стандартный механизм управления временем жизни операций — особенно для отмены работы и распространения таймаутов через цепочку вызовов функций.

## Основная проблема, которую он решает

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

## Создание контекстов

```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` создают дочерний контекст, который можно отменить; вы должны вызвать `defer cancel()`, чтобы освободить его ресурсы.

## Реагирование на отмену

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

Функции проверяют `ctx.Done()` (канал, который закрывается при отмене) и останавливаются быстро — вот как отмена фактически распространяется.

## Передача контекста через цепочку вызовов (соглашение)

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

Контекст передаётся вниз по стеку вызовов как первый параметр, поэтому отмена достигает каждого слоя (включая вызовы стандартной библиотеки для БД/HTTP, которые принимают контекст).

## Значения, привязанные к запросу (используйте осторожно)

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

## Почему это важно

Пакет `context` является фундаментом для написания надёжных, готовых к использованию в production Go-сервисов — это стандартный, идиоматичный способ обработки **отмены и таймаутов** между горутинами и границами API.

Его основная ценность — предотвращение потраченной впустую работы и утечек ресурсов: когда клиент отключается, проходит крайний срок или сервер выключается, контекст распространяет сигнал отмены, чтобы все горутины и операции, запущенные для этого запроса, остановились быстро, а не выполнялись бесполезно (ключевая защита от утечек горутин).

Он повсеместен в реальном Go — HTTP-серверы, вызовы БД, gRPC и большинство сетевых библиотек принимают `context.Context` как первый параметр.

Понимание создания контекстов (`WithTimeout`/`WithCancel`), реагирования на отмену (`<-ctx.Done()`), правила обязательного вызова `cancel()` и соглашения о передаче контекста через цепочки вызовов является необходимым для любой серьёзной работы с Go backend и частой темой на собеседованиях.