Context paketi ne için kullanılır?

Question

Accepted Answer

**`context`** paketi **iptal sinyalleri, deadline'lar ve istek kapsamı değerleri** API sınırları ve goroutine'ler arasında taşır. İşlemlerin ömrünü kontrol etmenin standart mekanizmasıdır — özellikle çalışmayı iptal etmek ve timeout'ları bir işlev çağrısı zinciri aracılığıyla yayılmak için.

## Çözdüğü temel sorun

```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'ler oluşturma

```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` iptal edilebilen bir alt context türetir; kaynakları serbest bırakmak için `defer cancel()` çağırmalısınız.

## İptale yanıt verme

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

İşlevler `ctx.Done()` (iptal sırasında kapanan bir kanal) kontrol eder ve hızla durur — bu, iptali gerçekte nasıl yayıldığını gösterir.

## Çağrı zinciri boyunca context'i geçirme (kural)

```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 çağrı stack'i aşağıya doğru ilk parametre olarak akar, böylece iptal her katmana ulaşır (context'i kabul eden standart kütüphane DB/HTTP çağrıları da dâhil).

## İstek kapsamı değerleri (seyrek kullanın)

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

## Neden önemli

**`context`** paketi sağlam, üretime hazır Go hizmetleri yazmanın temelini oluşturur — goroutine'ler ve API sınırları arasında **iptal ve timeout'ları** işlemenin standart, deyimsel yoludur.

Asıl değeri, boşa harcanan işi ve kaynak sızıntılarını önlemektir: bir müşteri bağlantısı kapandığında, bir deadline geçtiğinde veya sunucu kapatıldığında, context iptal sinyalini yayar, böylece o istek için oluşturulan tüm goroutine'ler ve işlemler işe yaramayan şekilde çalışmak yerine hızla durur (goroutine sızıntılarına karşı önemli bir savunma).

Gerçek Go'da her yerde bulunur — HTTP sunucuları, veritabanı çağrıları, gRPC ve çoğu ağ kütüphanesi ilk parametre olarak `context.Context` kabul eder.

Context'leri nasıl oluşturacağınızı (`WithTimeout`/`WithCancel`), iptal etmeye nasıl yanıt vereceğinizi (`<-ctx.Done()`), `cancel()` çağırmanın zorunlu kuralını ve context'i çağrı zincirleri boyunca iletme kuralını anlamak, ciddi Go arka uç çalışması için gereklidir ve sık görülen bir mülakat konusudur.